1、对象和封装
1.1、构造方法
语法：
[ 访问修饰符 ] 方法名 ( [ 参数列表 ] ){
//……省略方法体的代码
}
-
构造方法的名称必须和类名相同，但是没有返回值类型。在构造方法的定义中参数列表是可选的，因此可以定义无参构造方法，也可以定义带参构造方法。
-
在java中，每一个类都默认自带了一个构造方法叫做缺省构造器，如有没有创建，则系统会自动创建一个默认的构造方法，默认构造方法是没有参数的，而且在方法体中没有代码。（无参构造器）
注意： 当我们创建了构造方法之后，Java自带的无参构造方法就会消失，需要我们自己写出来
1.2、this
this 的三种用法：
1、使用 this 关键字调用成员变量，解决成员变量和局部变量的同名冲突
public Strive(String name){
this.name = name; //成员变量和局部变量同名，必须使用 this 关键字
}
2、使用 this 关键字调用成员方法
public Strive(String name){
this.name = name;
this.print(); // 调用成员方法
}
3.使用 this 关键字调用已定义的构造方法
在以下代码中定义了 Strive 类，并定义了两个带参构造方法
public void Strive(){
String name;
String sex;
int age;
String dept;
public Strive(String name, String sex){
this.name = name;
this.sex = sex;
}
public Strive(String name, String sex, int age, String dept){
this(name,sex); //调用已定义的构造方法（调用上面那个构造方法）
this.age = age;
this.dept = dept;
}
}
以上使用 this 关键字调用构造方法，并传入局部变量 name 和 sex 作为参数，执行时，首先执行 Strive(String name,String sex) 构造方法，完成对 name 属性和 sex 属性的赋值，然后执行后面的语句实现对 age 属性和 dept 属性的赋值。
1.3、方法重载
1.3.1、方法重载的定义
方法重载指的是同一个类包含两个或两个以上的方法，它们的方法名相同，方法参数个数不同，
方法参数类型不同。成员方法和构造方法都可以进行重载
例如：
System.out.println("good");
System.out.println(true);
System.out.println(100);
这里的方法重载使用的是方法参数类型不同
1.3.2、方法重载的特点
方法重载判断的依据如下：
- 必须在同一个类中
- 方法名相同
- 参数列表 （方法参数的个数或参数类型） 不同
注意： 方法的返回值和方法的访问修饰符不能作为判断方法之间是否构成重载的依据
1.3.3、方法重载的使用和优点
public int Strive(int a,int b){
return a+b;
}
public double Strive(double a,double b){
return a+b;
}
public String Strive(String s1,String s2){
return s1+s2;
}
public static void main(String[] args) {
Adder adder = new Adder();
int a = 6,b = 8;
System.out.println(adder.Strive(a,b));
double c = 9 , d = 10.9;
System.out.println(adder.Strive(c,d));
String s1 = "Hello",s2 = "World";
System.out.println(adder.Strive(s1,s2));
}
- 由以上代码可见，方法重载是对原有方法的一种升级，可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，简化了类调用方法的代码
1.3、使用封装重构类的属性和方法
1.3.1、封装的概念
封装是面向对象的三大特性之一，就算将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法实现对隐藏信息的操作和访问。
封装反映了事物的相对独立性，有效避免了外部错误对此对象的影响，并且能够给用户由于大意产生的错误操作起到预防作用
- 好处： 封装的好处在于隐藏类的细节，让用户只能通过开发人员规定的方法访问数据，可以方便地加入访问修饰符来限制不合理操作
1.3.2、封装的步骤
实现封装的步骤如下：
1、修改属性的可见性来限制对属性的访问
2、 为每个属性创建一对赋值（setter）方法和取值（getter）方法，用户对这些属性的存取
3、在赋值方法中，可以加入对属性的存取控制语句
1、修改属性的可见性：
使用 private 访问修饰符修饰，private 修饰的属性和方法只能在定义它的类的内部被访问
2、创建赋值和取值方法：
get 方法取值、 set 方法存值
get 方法读、 set 方法改
以上看哪一个能理解，意思一致，代码如下：
private String name; // 私有属性
public void getName(){ //get方法 读
return name;
}
public void setName(String name){ //set 改
this.name = name;
}
3、加入对属性的存取控制语句
为了限制不合理赋值，除了设置属性的私有性，还可以在赋值方法中加入对属性的存取控制语句。
假如性别：只有男，女，年龄：0~100 ;代码如下：
private grnder; // 性别
private int age; // 年龄
// 省略get 方法
public void setAge(int age){ //控制年龄
if(age < 0 || age > 150){
System.out.println("输入的年龄为:"+age+",该年龄不合法！");
return;
}else{
this.age = age;
}
}
public void setGender(String gender) { //控制性别
if(gender.equals("男") || gender.equals("女")){
this.gender = gender;
}else{
System.out.println("*** 性别不合法 ！***");
}
}
1.4、类和类成员的访问控制
1、类和访问修饰符
| 修饰符 | 同一包中 | 非同一包中 |
|---|---|---|
| public | 可以使用 | 可以使用 |
| 默认修饰符 | 可以使用 | 不可以使用 |
省略访问修饰符，就算默认修饰符
2、类成员的访问修饰符
| 修饰符 | 同一类中 | 同一包中 | 子类中 | 外部包 |
|---|---|---|---|---|
| private | 可以使用 | 不可以使用 | 不可以使用 | 不可以使用 |
| 默认修饰符 | 可以使用 | 可以使用 | 不可以使用 | 不可以使用 |
| protected | 可以使用 | 可以使用 | 可以使用 | 不可以使用 |
| public | 可以使用 | 可以使用 | 可以使用 | 可以使用 |
1.5、static 关键字
static 关键字可以修饰类的属性，方法和代码块。使用 static 修饰的属性和方法不再属于具体的某个对象，而属性它所在的类
使用 static 修饰的 属性或方法可以使用 “ 类名 . ” 的方式调用，不需要再消耗资源反复创建对象
使用 static 修饰的方法属于 静态方法，使用类名调用，static 修饰的变量属于静态变量，类加载的时候加载进方法区
1.5.1、用 static 关键字修饰属性和代码块
如下静态代码块：
static{
System.out.println("HelloWorld");
}
static 修饰的是类加载的时候执行，创建对象的时候执行，创建对象的时候应先执行 static静态代码块里面的内容
注意：
- 有多个静态代码块的时候，按照静态代码块的前后顺序执行
- 在方法里不可以定义 static 变量，也就是静态变量不能是局部变量
- 在静态方法中不能直接访问实例变量和实例方法
- 在实例方法中可以直接调用类中定义的静态变量和静态方法
2、继承
2.1、继承的基本概念
继承是面向对象的三大特征之一，继承可以解决编程中代码冗余的问题，是实现代码重用的重要手段之一。
语法：
[ 访问修饰符 ] class <SubClass> extends <SuperClass>{}
其中，SubClass 被称为子类或派生类，SuperClass 被称为父类或基类。
Java 继承规则如下：
1、可以继承父类中 public 和 protected 修饰的属性和方法，不论子类和父类是否在同一包中。
2、可以继承默认访问修饰符修饰的属性和方法，但是子类和父类必须在同一包中
3、无法继承 private 修饰的属性和方法
4、无法继承父类的构造方法
注意：
在 Java 中只支持单继承，即每个类只能有一个直接父类
2.2、继承的应用
如下：
/**
*动物父类
*/
public class Animal {
public void cry(){
System.out.println("动物叫。。。。");
}
}
/**
* 继承了动物类的小猫类也有 cry() 方法（子类）
*/
public class Cat extends Animal {
// 有父类的方法与属性
}
2.3、Object
Object 类属性超级父类（老祖宗），当一个类没有任何继承的时候，默认继承 Object 类，自带 Object 类里面的 方法与属性
注意：
子类被创建对象的时候必是先执行 Object 类的构造方法，因为构造方法第一行中有隐藏的 super() 调用父类构造方法，最终的父类一定是 Object 类
2.4、继承关系中的方法重写
子类通过继承可以拥有和父类相同的特征和行为，另外，子类也可以定义自己特有的行为，既沿袭了父类的方法名称，又重新实现了父类方法，这就是方法重写。
在子类中可以根据需求对从父类继承的方法进行重写编写，这被称为方法重写或方法覆盖。
方法重写必须遵守以下规则：
- 重写方法和被重写方法必须具有相同的方法名
- 重写方法和被重写方法必须具有相同的参数列表
- 重写方法的返回值类型必须和被重写方法的返回值类型相同或是其子类
- 重写方法不能缩小被重写方法的访问权限
重写的时候可以在方法上面使用注解：
@Override
@Override 是用 Java 注解的方法表示该方法重写了父类方法，可以写也可以不写，在功能实现上没有区别，但是通过 @Override 注解，程序更加方便阅读。另外，编译器也会帮助验证 @Override 下面的方法名是否是父类所有的。如果其不符合方法重写规则，则会报错。
提示：
Java 注解又被称为 Java 标注，是 Java 5 引入的一种注解机制。
2.5、方法重载和方法重写的区别
- 方法重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型和访问修饰符无关
- 方法重写涉及的是子类和父类之间的同名方法，要求方法名相同，参数列表相同，返回值类型i相同或是其子类
2.6、super关键字
如果想在子类中调用父类的被重写的方法，可以使用 ” super.方法名 “实现
super 关键字代表对当前对象的直接父类对象的默认引用。在子类中可以通过 super 关键字访问父类的成员，包括父类的属性和方法。语法如下：
语法：
访问父类构造方法 ：super(参数)
访问父类属性 / 方法 ：super.< 父类属性 / 方法 >
使用 super 关键字，需要注意以下几点：
- super 关键字必须出现在子类（子类的方法和构造方法）中，而不允许在其他位置。
- 可以访问父类的成员，如父类的属性，方法，构造方法。
- 注意访问权限的限制，如无法通过 super 关键字访问 private 成员。
注意：
1、在构造方法中如果有 this 语句或 super 语句，则只能是第一条语句。
2、在一个构造方法中，不允许同时使用 this 关键字和 super 关键字调用构造方法（否则就有两条第一条语句）。
3、在静态方法中不允许出现 this 关键字或 super 关键字。
4、在实例方法中，this 语句和 super 语句不要求是第一条语句，可以共存。
5、子类构造方法中第一行有隐藏的 super( ) 调用父类构造方法，最终父类一定是 Object 类
2.7、继承关系中的构造方法
在 Java 中，一个类的构造方法在如下两种情况下会被执行：
- 创建该类对象（实例化）
- 创建该类的子类对象（子类的实例化）
子类在实例化时，会首先执行其父类的构造方法，然后才会执行子类的构造方法。
在 Java 语言中，当创建一个对象时，Java 虚拟机（JVM）会按照父类——>子类的顺序执行一系列的构造方法。
子类继承父类时构造方法的调用规则如下：
- 如果在类的构造方法中没有通过 super 关键字显式调用父类地带参构造方法，也没有通过 this 关键字显式调用自身地其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，是否写 “ super( ); ”语句，效果是一样的。
- 如果在子类的构造方法中通过 super 关键字显式地调用了父类地带参构造方法，那么将执行父类相应的构造方法，而不执行父类无参构造方法。
- 如果在子类的构造方法中通过 this 关键字显式地调用了自身地其他构造方法，那么在相应构造方法中遵循以上两条规则。
- 如果存在多级继承关系，则在创建一个子类对象时，以上规则会多次向上更高一级父类应用，直到执行顶级父类 Object 类的无参构造方法为止。
3、多态
面向对象的三大特性为 封装、继承、多态。最后一个特性——多态。它能使同一个操作当作用于不同的对象时，产生不同的执行结果。
使用多态可以提高代码的可维护性和可扩展性
3.1、子类到父类的转换（向上转型）
子类到父类的转换被称为向上转型。（自动类型转换）
语法：
< 父类型 > < 引用变量名 > = new < 子类型 > ( );
Strive strive1 = new s1();
Strive 为父类型 strive1 为引用变量名 s1 为子类型
- 父类型的引用指向子类型的对象
实现多态的三个条件如下：
1、继承的存在（继承是多态的继承，没有继承就没有多态）。
2、子类重写父类的方法（多态下调用子类重写后的方法）。
3、父类引用变量指向子类对象（向上转型）。
3.2、父类到子类的转换（向下转型）
父类到子类的转换被称为向上转型。（强制类型转换）
语法：
< 子类型 > < 引用变量名 > = ( < 子类型 > ) < 父类型的引用变量 >;
Strive strive1 = (Strive)s1;
s1 为 父类型的引用变量，Strive 为子类型，strive1 为引用变量名
3.3、instanceof 运算符
语法：
对象 instanceof 类或接口
- 该运算符用来判断一个对象是否属于一个类或实现了一个接口，结果为 true 或 false。
- 在强制类型转换之前通过 instanceof 运算符检查对象的真实类型，再进行相应的强制类型转换，这样就可以避免类型转换异常，从而提高代码的健壮性。
if(Strive instanceof s1){ // 类型判断
Strive strive1 = (Strive)s1;
}else{
System.out.println("Strive与s1没有关系");
}
3.4、多态的优势
- 可替换性：多态对已存在的代码具有可替换性
- 可扩充性：多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性，继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。
- 灵活性：在多态的应用中，体现了灵活多样的操作，提高了使用效率。
- 简化性：多态简化了应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出
多态的使用大多体现在实际开发中，多写代码，多用多态，慢慢自然能够体验到多态的灵活性以及多态的重要性
4、三大特性总结
面向对象的三大特性：封装、继承、多态。
- 封装就是声明类的成员变量为私有的，同时提供公有的方法实现对该成员变量的存取操作。
- 继承是软件可重用性的一种表现，新类可以在不增加自身代码的情况下，通过从现有的类中继承其属性和方法充实自身内容，这种现象或行为被称为继承。
- 多态是具有表现多种形态的能力的特征。在程序设计的术语中，它意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用地对象的方法，也就是根据作用到的不同的对象类型，响应不同的操作。
封装、继承、多态三大特性在Java中非常非常非常重要，一定要统统理解
扫一扫
342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
