JavaSE——类和对象-创新互联
目录
我们提供的服务有:网站设计、成都网站设计、微信公众号开发、网站优化、网站认证、康巴什ssl等。为上千余家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务,是有科学管理、有技术的康巴什网站制作公司一、万物皆对象
二、类的定义方式以及对象的实例化
1.类的定义方式
2.对象的实例化
三、类中的成员变量和成员方法的使用
1.static修饰成员变量
2.static修饰成员方法
四、对象的整个初始化过程
1. 初始化对象
2.构造方法
3.默认初始化
4.就地初始化
五、封装特性
访问限定符
六、代码块
1.普通代码块
2.构造代码块
3.静态代码块
七、内部类
1.成员内部类
1)普通内部类
2)静态内部类
2.局部内部类
一、万物皆对象
1. 在学习类和对象之前先了解一下面向对象的过程:
一图可解传统洗衣服都面向一个过程:拿水盆->倒水->放衣服->放洗衣粉->手搓->换水->放洗衣粉->手搓->拧干->晾衣服,少一个环节可能都不行
2.那么接下来关于面向对象洗衣服:
二、类的定义方式以及对象的实例化以面向对象方式来进行处理,就不关注洗衣服的过程,具体洗衣机是怎么来洗衣服,如何来甩干的,用户不用去关心,只需要将衣服放进洗衣机,导入洗衣粉,启动开关
类是用来对一个实体(对象),主要描述该实体(对象)具有哪些属性(外观尺寸等),哪些功能(用来干啥)
1.类的定义方式- class为定义类的关键字,ClassName为类的名字,{}中为类的主体
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
- 类中包含的内容称为类的成员,属性主要是用来描述类的,称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能,称为类的成员方法
public class WashMachine {
public String brand;// 品牌
public String type;// 型号
public double weight;// 重量
public double lenght;// 长
public double weigth;// 宽
public double height;// 高
public String color;// 高
public void washClothes(){// 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){// 脱水
System.out.println("脱水功能");
}
public void setTime(){// 定时
System.out.println("定时功能");
}
}
- 小练习巩固定义类:
public class PetDog {
//定义一个狗类
public String name;//名字
public String color;//颜色
// 狗的属性
public void barks(){
System.out.println(name+":汪汪汪~~~");
}
// 狗的行为
public void wag(){
System.out.println(name+":摇尾巴~~~");
}
}
2.对象的实例化- 用类类型创建对象的过程,称为类的实例化,在java中采用new关键字,配合类名来实例化对象
public class Main {
//实例化
public static void main(String[] args) {
PetDog dogh = new PetDog();//通过new实例化对象
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();
PetDog dogs = new PetDog();
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();
}
}
- this引用的是调用成员方法的对象
public class Date {
public int year;
public int month;
public int day;
public void setDay(int year,int month,int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year+"/"+this.month+"/"+this.day);
}
public static void main(String[] args) {
Date d = new Date();
d.setDay(2023,1,12);
d.printDate();
}
}
三、类中的成员变量和成员方法的使用 1.static修饰成员变量【this引用的特性】
1. this的类型:对应类类型引用,哪个对象调用就是哪个对象的引用类型 2. this只能在 " 成员方法 " 中使用 3. 在 " 成员方法 " 中, this 只能引用当前对象,不能再引用其他对象 4. this是 “ 成员方法 ” 第一个隐藏的参数,编译器会自动传递
- static修饰的成员变量,称为静态成员变量
public class Student1{
public String name;
public String sex;
public int age;
public double score;
public static String classRoom = "Bit306";
public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问
System.out.println(Student1.classRoom);
Student1 s1 = new Student1("LiLeiLei","男",18,3.8);
Student1 s2 = new Student1("HanMeiMei","女",19,4.0);
Student1 s3 = new Student1("Jim","男",18,2.6);
// 也可以通过对象访问:但是classRoom是三个对象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}
2.static修饰成员方法【静态成员变量特性】
1. 不属于某个具体的对象,是类的属性,所有对象共享不存储在某个对象的空间中 2. 既可以通过对象访问,也可以通过类名访问 3. 类变量存储在方法区当中 4. 生命周期伴随类的一生 ( 随类的加载而创建,随类的卸载而销毁 )
- Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般是通过静态方法来访问
public class Student2 {
public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "Bit306";
public static String getClassRoom(){
return classRoom;
}
public static void main(String[] args) {
System.out.println(Student2.classRoom);
}
}
四、对象的整个初始化过程 1. 初始化对象【静态方法特性】
1. 不属于某个具体的对象,是类方法
2. 可以通过对象调用,也可以通过类名.静态方法名(...)方式调用
3. 静态方法没有隐藏的this引用参数
4. 静态方法中不能调用任何非静态方法
- 需要调用之前写的SetDate方法才可以将具体的日期设置到对象中
- 构造方法(也称为构造器)是一个特殊的成员方法,名字必须与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次
public class Date {
public int year;
public int month;
public int day;
// 构造方法:
// 名字与类名相同,没有返回值类型,设置为void也不行
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次
public Date(int year,int month,int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year+"/"+this.month+"/"+this.day);
}
public static void main(String[] args) {
// 此处创建了一个Date类型的对象,并没有显式调用构造方法
Date d = new Date(2023,1,12);// 输出Date(int,int,int)方法被调用了
d.printDate();//2023/1/12
}
}
3.默认初始化【构造方法特性 】
1. 名字必须与类名相同 2. 没有返回值类型,设置为 void 也不行 3. 创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次 4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )public class Date1 { public int year; public int month; public int day; //无参构造方法 public Date1() { this.year = 2023; this.month = 1; this.day = 12; } //带有三个参数的构造方法 public Date1(int year, int month, int day) { this.year = year; this.month = month; this.day = day; } public void printDate(){ System.out.println(year+"-"+month+"-"+day); } public static void main(String[] args) { Date1 d = new Date1(); d.printDate(); } }
- 名字相同,参数列表不同构成了方法重载
5. 如果用户没有显式定义,编译器会生成一份默认的构造方法,生成的默认构造方法一定无参
public class Snakek {
private int age;
public static void main(String[] args) {
Snakek snakek = new Snakek();
System.out.println(snakek.age);//0
}
}
- 要搞清楚这个过程,就需要知道 new 关键字背后所发生的一些事情
4.就地初始化在程序层面只是简单的一条语句,在JVM层面需要做好多事情,下面简单了解:
1. 检测对象对应的类是否加载了,如果没有加载则加载 2. 为对象分配内存空间 3. 处理并发安全问题 4. 初始化所分配的空间
- 在声明成员变量时,就直接给出了初始值
public class Date2 {
public int year = 2023;
public int month = 1;
public int day = 12;
public Date2() {
}
public Date2(int year, int month, int day) {
}
public static void main(String[] args) {
Date2 d1 = new Date2(2023,1,12);
Date2 d2 = new Date2();
}
}
五、封装特性封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行 交互
访问限定符public :可以理解为一个人的外貌特征,谁都可以看得到 default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密,对于其他人来说就是隐私了 private :只有自己知道,其他人都不知道
public class Computer {
private String cpu;//cpu
private String memory;//内存
public String screen;//屏幕
String brand;// 品牌---->default属性
public Computer(String cpu, String memory, String screen, String brand) {
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
this.brand = brand;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW","17","8G","13*14");
System.out.println(p.brand);// default属性:只能被本包中类访问
System.out.println(p.screen);// public属性: 可以任何其他类访问
//System.out.println(p.cpu);// private属性:只能在Computer类中访问,不能被其他类访问
}
}
- 一般情况下成员变量设置为private,成员方法设置为public
1.普通代码块使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字可分为以下四种 :普通代码块 、构造块 、静态块 、同步代码块(后续讲解多线程部分再谈)
- 普通代码块:定义在方法中的代码块
public class Main {
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10;
System.out.println("x1 = "+x);//x1 = 10
}
int x = 100;
System.out.println("x2 = "+x);//x2 = 100
}
}
2.构造代码块 - 构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一般用于初始化实例成员变量
public class Student {
//实例成员变量
private String name;
private String sex;
private int age;
private double score;
public Student() {
System.out.println("l am Student in it ()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}
3.静态代码块 - 使用static定义的代码块称为静态代码块,一般用于初始化静态成员变量
public class Student1 {
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例化代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
//静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student1() {
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student1 s1 = new Student1();
Student1 s2 = new Student1();
}
}
七、内部类【注意事项】
1.静态代码块不管生成多少个对象,其只会执行一次
2.静态成员变量是类的属性
3.如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次合并,最终放在生成的方法中,该方法在类加载时调用,并且只调用一次
4.实例代码块只有在创建对象时才会执行
- 在 Java 中,可以将一个类定义在另一个类或者一个方法的内部,前者称为内部类,后者称为外部类。内部类也是封装的一种体现
1)普通内部类在外部类中,内部类定义位置与外部类成员所处的位置相同
- 未被static修饰的成员内部类
public class OutClass1 {
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 成员内部类:未被static修饰
class InnerClass{
int c;
public void methodInner(){
// 在内部类中可以直接访问外部类中:任意访问限定符修饰的成员
a = 100;
b = 200;
methodA();
methodB();
// 如果外部类和内部类中具有相同名称成员时,优先访问的是内部类自己的
c = 300;
System.out.println(c);
// 如果要访问外部类同名成员时候,必须:外部类名称.this.同名成员名字
OutClass1.this.c = 400;
System.out.println(c);
}
}
public static void main(String[] args) {
// 外部类:对象创建 以及 成员访问
OutClass1 outClass1 = new OutClass1();
System.out.println(outClass1.a);
System.out.println(outClass1.b);
System.out.println(outClass1.c);
outClass1.methodA();
outClass1.methodB();
System.out.println("=============内部类的访问=============");
// 创建内部类对象
InnerClass innerClass = new OutClass1().new InnerClass();
// 先将外部类对象先创建出来,然后再创建内部类对象
InnerClass innerClass2 = outClass1.new InnerClass();
innerClass2.methodInner();
}
}
【 注意事项 】 1. 外部类中的任何成员都可以被在普通内部类方法中直接访问 2. 在内部类方法中访问同名的成员时,优先访问自己的 3. 普通内部类对象必须在先有外部类对象前提下才能创建 4. 外部类中,不能直接访问内部类中的成员,如果要访问必须先要创建外部类的对象2)静态内部类
- 被static修饰的内部成员类称为静态内部类
public class OutClass2 {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 静态内部类:被static修饰的成员内部类
static class InnerClass{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
//a = 100; // 编译失败,因为a不是类成员变量
b = 200;
//methodA(); // 编译失败,因为methodB()不是类成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
InnerClass innerClass = new InnerClass();
innerClass.methodInner();
}
}
【 注意事项 】 1. 在内部类中只能访问外部类中的静态成员 2. 创建内部类对象时,不需要先创建外部类对象2.局部内部类
- 定义在外部类的方法体或者{}中
public class OutClass3 {
int a = 10;
public void method(){
int b = 10;
// 局部内部类:定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用,其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
//OutClass2.InnerClass innerClass = null;编译失败
}
}
【 注意事项 】 1. 局部内部类只能在所定义的方法体内部使用 2. 不能被 public 、 static 等修饰符修饰与君共勉:时间最不偏私,给任何人都是二十四小时;时间也最偏私,给任何人都不是二十四小时
你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧
新闻名称:JavaSE——类和对象-创新互联
标题URL:http://scyanting.com/article/disiph.html