封装、继承、多态、修饰符

已于 2023-03-01 10:50:32 修改
阅读量70 收藏 1
点赞数
文章标签： java
于 2021-11-06 21:15:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63262602/article/details/121185035
版权

目录

JAVA对象的创建和使用

封装

封装的步骤

作用和意义

方法重载

继承

继承

Object类

Super关键字

 super的使用

super使用的注意的地方

super 和 this 的区别

方法重写

 重写的语法：

多态

认识多态

重写、重载和多态的关系

多态的注意事项

多态的存在条件

方法绑定

instanceof和类型转换

instanceof

类型转换

修饰符

static修饰符

static变量

static方法

代码块和静态代码块

创建和初始化对象的过程

静态导入

final修饰符

修饰类

修饰方法

修饰变量

abstract修饰符

抽象类和抽象方法的关系 

语法

特点及作用

 

 

JAVA对象的创建和使用

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

封装

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

封装的步骤

1. 使用private 修饰需要封装的成员变量。
2. 提供一个公开（public）的方法设置或者访问私有的属性
  • 访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写
  • 设置 通过set方法，命名格式： set属性名（）; 属性的首字母要大写
//set负责给属性赋值 
//get负责返回属性的值

 public class Student{
 
 private String name;
 public void setName(String name){
 this.name = name;
 }

public String getName(){
 return this.name;
 }
 }


public class Test{
 public static void main(String[] args){
 Student s = new Student();
 s.setName("tom");
 System.out.println(s.getName());
}
}

作用和意义

1. 提高程序的安全性，保护数据。
2. 隐藏代码的实现细节
3. 统一用户的调用接口
4. 提高系统的可维护性
5. 便于调用者调用。
良好的封装，便于修改内部代码，提高可维护性。
良好的封装，可进行数据完整性检测，保证数据的有效性。

方法重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。
方法的重载可以提供方法调用的灵活性。 
public class Test{
 public void test(String str){

 }

public void test(int a){

 }
}

条件：

1. 方法名必须相同
2. 参数列表必须不同(参数的类型、个数、顺序的不同)
3. 方法的返回值可以不同，也可以相同。

继承

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

继承

1.JAVA中类只有单继承，没有多继承！ 接口可以多继承！
2.继承是类和类之间的一种关系。
3.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。 
public class student extends Person{

 }

student is person
4.类和类之间的继承是单继承：
一个子类只能"直接"继承一个父类；一个父类可以被多子类继承；
5.父类中的属性和方法可以被子类继承；

Object类

  • java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。
  • 在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法。(因为Object是所以类的父类)    例如:toString方法、equals方、getClass方法等；

Super关键字

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16 watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法；使用super就表示访问或调用父类中的属性和方法。

 super的使用

//访问父类中的属性
public class Person{
 protected String name = "zs";
 }

public class Student extends Person{
 private String name = "lisi";
 public void tes(String name){
 System.out.println(name);
 System.out.println(this.name);
 System.out.println(super.name);
 }
 }
//调用父类中的方法
public class Person{
 public void print(){
 System.out.println("Person");
 }
 }

public class Student extends Person{
 public void print(){
 System.out.println("Student");
 }
public void test(){
 print();
 this.print();
 super.print();
 }
 }
//调用父类中的构造器
public class Person{

 }
public class Student extends Person{
 //编译通过,子类构造器中会隐式的调用父类的无参构造器
 //super();
 public Student(){

 }
 }

 

//父类没有无参构造
 public class Person{
 protected String name;
 public Person(String name){
 this.name = name;
 }
 }
public class Student extends Person{
 //编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
 //super();
 public Student(){

 }
 }
//显式的调用父类的有参构造器
 public class Person{
 protected String name;
 public Person(String name){
 this.name = name;
 }
 }
public class Student extends Person{
 //编译通过,子类构造器中显式的调用父类的有参构造器
 public Student(){
 super("tom");
 }
 }
不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。 
 public class Person{
 protected String name;
 public Person(String name){
 this.name = name;
 }
 }
public class Student extends Person{
 //编译报错,super调用构造器的语句不是第一行代码
 public Student(){
 System.out.println("Student"); 
 super("tom");
 }
 }

super使用的注意的地方

1. 用super调用父类构造方法，必须是构造方法中的第一个语句。
2. super只能出现在子类的方法或者构造方法中。
3. super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

super 和 this 的区别

1. 代表的事物不一样:
this：代表所属方法的调用者对象。super：代表父类对象的引用空间。
2.使用前提不一致：
this：在非继承的条件下也可以使用。super：只能在继承的条件下才能使用。
3.调用构造方法：
this：调用本类的构造方法。super：调用的父类的构造方法

方法重写

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

 

1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写。
2. 静态方法不能重写。（有static）
  • 父类的静态方法不能被子类重写为非静态方法 //编译出错
  • 父类的非静态方法不能被子类重写为静态方法；//编译出错
  • 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
A类继承B类 
A和B中都一个相同的静态方法test

 B a = new A();
 a.test();//调用到的是B类中的静态方法test

 A a = new A();
 a.test();//调用到的是A类中的静态方法test

 可以看出静态方法的调用只和变量声明的类型相关
 这个和非静态方法的重写之后的效果完全不同

 

1. 私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。 
 public class Person{
 private void run(){

}
 }
//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法

 public class Student extends Person{
 private void run(){

}
 }

 重写的语法：

1. 方法名必须相同
2. 参数列表必须相同
3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
4. 抛出异常类型的范围可以被缩小,但是不能被扩大
ClassNotFoundException ---> Exception
5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回
类型的子类型
例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型 
public class Person{
public void run(){} 
 
protected Object test()throws Exception{
 return null;
}
 }
//编译通过,子类继承父类,重写了run和test方法.
 public class Student extends Person{
 public void run(){}

 public String test(){
 return "";
 } 
}

//一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号中代码不一样)
  • 方法重写的时候，必须存在继承关系。
  • 方法重写的时候，方法名和形式参数 必须跟父类是一致的。
  • 方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected < public，friendly < public )
  • 方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系
  • 方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

多态

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

认识多态

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
相同类域的不同对象,调用相同的方法,执行结果是不同的。
 
1. 一个对象的实际类型是确定的 
例如: new Student(); new Person();等

2. 可以指向对象的引用的类型有很多

//一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种
 （所属类型）Student s1（对象） = new Student();（实现类型）
 Person s2 = new Student();
 Object s3 = new Student();

//一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。

 

// 一个父类引用可以指向它的任何一个子类对象 
Object o = new AnyClass();
 Person p = null;
（子类对象） p = new Student();（父类引用）
 p = new Teacher();
 p = new Person();
//多态中的方法调用
public class Person{
 public void run(){}
 }

public class Student extends Person{ }
// 调用到的run方法,是Student从Person继承过来的run方法
main:
 Person p = new Student();
 p.run();

 

 public class Person{
 public void run(){}
 }

public class Student extends Person{
 public void run(){
 //重写run方法 } 
}

 main:
 Person p = new Student();
 p.run();//调用到的run方法,是Student中重写的run方法
注：子类继承父类,调用a方法.
如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法; 如果重写了,那么调用的就是重写之后的方法。
  
//子类中独有方法的调用
 public class Person{
 public void run(){}
 }

 public class Student extends Person{
 public void test(){ }
 }

main:
 Person p = new Student();
//调用到继承的run方法
 p.run();
 //编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编译报错. 
 p.test();
注:一个变量x,调用一个方法test.
编译器是否能让其编译通过,主要是看声明变量x的类型中有没有定义test方法,如果有则编译通过,如果没有则编译报错.而不是看x所指向的对象中有没有test方法.
原理：编译看左边，运行不一定看右边。
  
//子类引用和父类引用指向对象的区别
Student s = new Student(); 
Person p = new Student();
变量s能调用的方法是Student中有的方法(包括继承过来的);变量p能调用的方法是Person中有的方法(包括继承过来的)。
 
但是变量p是父类型的,p不仅可以指向Student对象,还可以指向Teacher类型对象等,但是变量s只能指Studnet类型对象,及Student子类型对象。变量p能指向对象的范围是比变量s大的。
 
Object类型的变量o,能指向所有对象,它的范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法,因为变量o声明的类型就是Object.
注：java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。

重写、重载和多态的关系

重载是编译时多态 ;
调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错;
 
重写是运行时多态
调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。

多态的注意事项

1. 多态是方法的多态，属性没有多态性。
2. 编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。
3. 多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

多态的存在条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象
 
补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：
1. static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2. fifinal方法，因为被fifinal修饰的方法无法被子类重写
3. private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的。

方法绑定

 

 

 

 

instanceof和类型转换

instanceof

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

System.out.println(x instanceof Y);
该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有"子父类关"系就编译通过；没有子父类关系就是编译报错.

类型转换

 public class Person{
 public void run(){}
 }
 public class Student extends Person{
 public void go(){}
 }
 public class Teacher extends Person{ }
//编译报错,因为p声明的类型Person中没有go方法
 Person p = new Student();
 p.go();
 //需要把变量p的类型进行转换
 Person p = new Student();
 Student s = (Student)p;//或者((Student)p).go();
 s.go();
 
//注意第二种这种形式前面必须要俩个小括号
 
//类型转换中的问题

//编译通过 运行没问题
 Object o = new Student();
 Person p = (Person)o;

 //编译通过 运行没问题
Object o = new Student();
Student s = (Student)o;

 //编译通过,运行报错
 Object o = new Teacher();
 Student s = (Student)o;

//即: X x = (X)o; 运行是否报错,主要是变量o所指向的对象实现类型,是不是X类型的子类型,如果不是则运行就会报错。
【总结】
1、父类引用可以指向子类对象，子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）
father；其中father前面的（Son）必须添加，进行强制转换。
4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效
5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

修饰符

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16 ​​​​​watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

static修饰符

static变量

在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。 
 //静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问
 public class Student{
 private static int age;
 private double score;

 public static void main(String[] args) {
 Student s = new Student(); //推荐使用类名访问静态成员

 System.out.println(Student.age);
 System.out.println(s.age);
 System.out.println(s.score);
 }
 }

 

 public class Student{

 private static int count;
 private int num;

 public Student() {
 count++;
 num++;
 }

public static void main(String[] args) {
 Student s1 = new Student();
 Student s2 = new Student();
 Student s3 = new Student();
 Student s4 = new Student(); //因为还是在类中,所以可以直接访问私有属性 
 System.out.println(s1.num);
 System.out.println(s2.num);
 System.out.println(s3.num);
 System.out.println(s4.num);

 System.out.println(Student.count);
 System.out.println(s1.count);
 System.out.println(s2.count);
 System.out.println(s3.count);
 System.out.println(s4.count);
 }
 }

在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存，所以静态变量可以使用类名来直接访问,而不需要使用对象来访问.

static方法

在类中,使用static修饰的成员方法,就是静态方法,反之为非静态方法。
静态方法和非静态方法的区别：
  • 静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.
  • 静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态方法。
注意:this和super在类中属于非静态的变量.(静态方法中不能使用)
  
public class Student{
 private static int count;
 private int num;

 public void run(){}

 public static void go(){}

 public static void test(){
 //编译通过
 System.out.println(count);
 go();
 //编译报错
 System.out.println(num);
 run();
 }
}

 

//非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方
法

public class Student{
 private static int count;
 private int num;
 public void run(){}

 public static void go(){}

 public void test(){
 //编译通过
 System.out.println(count);
 go();
 //编译通过 
System.out.println(num);
 run();
 } 
}
静态方法和非静态方法不能直接相互访问? 加载顺序的问题！
  
//父类的静态方法可以被子类继承,但是不能被子类重写

public class Person {
 public static void method(){}
 }
//编译报错
 public class Student extends Person {
 public void method(){}
 }



//例如: 
 public class Person {
 public static void test() {
 System.out.println("Person");
 }
 }
//编译通过,但不是重写
 public class Student extends Person {
 public static void test(){
 System.out.println("Student");
 }
 }

main:
 Perosn p = new Student();
 p.test();//输出
Person p = new Person();
 p.test();//输出Perosn

//和非静态方法重写后的效果不一样
//父类的非静态方法不能被子类重写为静态方法

public class Person {
 public void test() {
 System.out.println("Person");
 }
 }
//编译报错
 public class Student extends Person {
 public static void test(){
 System.out.println("Student");
 }
 }

代码块和静态代码块

//类中可以编写代码块和静态代码块
public class Person {
 { 
//代码块(匿名代码块)
 }

static{
 //静态代码块
 } 
}
【匿名代码块和静态代码块的执行】
因为没有名字,在程序并不能主动调用这些代码块。
匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的时候都会自动执行.
静态代码块是在类加载完成之后就自动执行,并且只执行一次.
注:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次. 
public class Person {
 {
 System.out.println("匿名代码块");
 }

static{
 System.out.println("静态代码块");
 }

public Person(){
 System.out.println("构造器");
 }
 }

main:
 Student s1 = new Student();
 Student s2 = new Student();
 Student s3 = new Student();

 //输出
 静态代码块
 匿名代码块
 构造器

 匿名代码块 
 构造器

 匿名代码块
 构造器
【匿名代码块和静态代码块的作用】
匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。
静态代码块的作用是给类中的静态成员变量初始化赋值。
例如: 
public class Person {
 public static String name;

 static
{ name = "tom";
 }

public Person(){
 name = "zs";
 }

 }

main:
 System.out.println(Person.name);//tom
//在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才执行,但是静态变量可以不创建对象而直接使用类名来访问.

创建和初始化对象的过程

public class Person{
 private String name = "zs";

 public Person() {
 System.out.println("Person构造器");
 print();
 }
 public void print(){
 System.out.println("Person print方法: name = "+name);
 }
 }

public class Student extends Person{
 private String name = "tom";{
 System.out.println("Student匿名代码块");
 }

static{
 System.out.println("Student静态代码块");
 }
public Student(){
 System.out.println("Student构造器");
 }
public void print(){
 System.out.println("student print方法: name = "+name); 
}

public static void main(String[] args) {
 new Student(); }
 }

//输出：
 Student静态代码块
 Person构造器
 student print方法: name = null
 Student匿名代码块
 Student构造器

 Student s = new Student();
 Student类之前已经进行了类加载
 1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
 2.调用Student的父类构造器
 3.对Student中的属性进行显示赋值(如果有的话)
 4.执行匿名代码块
 5.执行构造器
 6.返回内存地址

 Student s = new Student();

【Student类之前没有进行类加载】
1. 类加载,同时初始化类中静态的属性
2. 执行静态代码块
3. 分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
4. 调用Student的父类构造器
5. 对Student中的属性进行显示赋值(如果有的话)
6. 执行匿名代码块
7. 执行构造器
8. 返回内存地址

静态导入

静态导包就是java包的静态导入，用import static代替import静态导入包，意思是导入这个类里的静态方法。 
import static java.lang.Math.random; 
import static java.lang.Math.PI;

 public class Test {
 public static void main(String[] args) {
 //之前是需要Math.random()调用的
 System.out.println(random());
 System.out.println(PI);
 }
 }
好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。

final修饰符

修饰类

用final修饰的类不能被继承,没有子类。

public final class Action{}

//编译报错
 public class Go extends Action{ }
例如:我们是无法写一个类去继承String类,然后对String类型扩展的,因为API中已经被String类定义为final的了.

修饰方法

用fifinal修饰的方法可以被继承,但是不能被子类的重写。 
public class Person{
 public final void print(){}
 }
//编译报错
 public class Student extends Person{
 public void print(){ }
 }

修饰变量

用fifinal修饰的变量表示常量,只能被赋一次值.其实使用fifinal修饰的变量也就成了常量了,因为值不会再变了。 
//【修饰局部变量】
public class Person{
 public void print(final int a){
 //编译报错,不能再次赋值,传参的时候已经赋过了
 a = 1;
}
 }
public class Person{
 public void print(){ 
final int a;
 a = 1;
 //编译报错,不能再次赋值
 a = 2;
 }
 }
//修饰成员变量-非静态成员变量

public class Person{
 private final int a;
 }
只有一次机会,可以给此变量a赋值的位置:
 声明的同时赋值
 匿名代码块中赋值 
构造器中赋值(类中出现的所有构造器都要写)
//修饰成员变量-静态成员变量

public class Person{
 private static final int a;
 }
只有一次机会,可以给此变量a赋值的位置:
 声明的同时赋值
 静态代码块中赋值
//修饰引用变量

main:
 final Student s = new Student();
 //编译通过
 s.setName("tom");
 s.setName("zs");
 //编译报错,不能修改引用s指向的内存地址
 s = new Student();

abstract修饰符

watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAaXNfa2Q=,size_20,color_FFFFFF,t_70,g_se,x_16

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

抽象类和抽象方法的关系 

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

语法

public abstract class Action{
 public abstract void doSomething();
 }

public void doSomething(){...}
对于这个普通方法来讲:
"public void doSomething()"这部分是方法的声明
"{...}"这部分是方法的实现。
如果大括号中什么都没写,就叫方法的空实现。
 
声明类的同时,加上abstract修饰符就是抽象类
声明方法的时候,加上abstract修饰符,并且去掉方法的大口号,同时结尾加上分号,该方法就是抽象方法。

特点及作用

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。 
public abstract class Action{
 public abstract void doSomething();
 }

main:
 //编译报错,抽象类不能new对象
 Action a = new Action();

 //子类继承抽象类
 public class Eat extends Action{
 //实现父类中没有实现的抽象方法，否则这个子类也要声明为抽象类。
 public void doSomething(){
 //code
 }
}

main: 
Action a = new Eat();
 a.doSomething();

 

 

 

 

 

 

 

 

 

查看源码：ctrl+右键

 

 

 

ChengLAA
关注
专栏目录
java封装继承多态的理解_深入理解Java面向对象三大特性 封装 继承 多态
weixin_39632397的博客
02-25 507
1.封装封装的定义：首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系为什么需要封装：封装符合面向对象设计原则的第一条：单一性原则，一个类把自己该做的事情封装起来，而不是暴露给其他类去处理，当内部的逻辑发生变化时，外部调用不用因此而修改，他们只调用开放的接口，而不用去关心内部的实现举例：public class Human{private in...
C#里封装 继承 多态（包教包会）
qq_42075398的博客
09-15 8505
一、封装 C#中可使用类来达到数据封装的效果，这样可以使数据与方法封装成单一元素，以便于通过方法存取数据。除此之外，还可以控制数据的存取方式。 在面向对象编程中，大多数都是以类作为数据封装的基本单位。类将数据和操作数据的方法结合成一个单位。设计类时，不希望直接存取类中的数据，而是希望通过方法来存取数据。这样就可以达到封装数据的目的，方便以后的维护升级，也可以在操作数据时多一层判断。 此外，封...
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 4159
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
封装继承多态（详解）
weixin_45847110的博客
08-15 1363
封装继承多态
封装、继承、多态
Tower_SHR的博客
06-23 693
文章目录面向对象的封装性为什么封装怎么封装面向对象的继承性 面向对象的封装性 为什么封装 新建两个类：用户类、用户测试类 package day01.encapsulation; /** * @author 衣鱼 *用户类 */ public class User { int age; } package day01.encapsulation; /** * @author 衣鱼 *用户的测试类 * user类中的age属性在外部程序中可以随意访问，导致age属性 * 不安全。用户年龄被
C++中的封装继承多态
m0_46663240的博客
07-31 797
之后当我学习了面向对象的分析设计编程思想，开始考虑通过封装、继承、多态把程序的耦合度降低，传统印刷术的问题就在于所有的字都刻在同一版面上造成耦合度太高所致，开始用设计模式使得程序更加的灵活，容易修改，并且易于复用。多态不同对象收到相同的的消息时（即调用相同的函数），产生不同的动作。继承就是派生类会获得父类所有公开权限的成员函数和成员变量，这样少去了重新定义的麻烦，另外派生类还可以增加其他的函数，扩展父类，以及重写父类函数，增加这个可拓展性，因为会遇到很多不同的情况，如果没有这种应变能力，就太死板了。...
Java面向对象三大特性(封装继承多态)解释及案例
coderge's CSDN Blog.
11-12 1679
继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过。测试类中添加一个方法showEmpAnnual(Employee e),实现获取任何员工对象的年工资，并在main方法中调用该方法[e.getAnnual()]简单的说:方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样那么我们就说子类的这个方法覆盖了父类的那个方法。
Java的封装继承多态简介与实例
Newbeemao的博客
03-27 487
继承是面向对象语言一个重要的部分，本质就是代码的复用，防止重复代码的多次书写，当一个类继承另一个类时，子类会拥有父类中的代码，但不是所有都能够继承，private修饰的内容、不在同一个包时的默认修饰符的内容以及构造方法。，Pet类型的对象pet指向了Cat的引用，所谓封装就是访问权限控制，不允许调用者直接访问类的属性，使用private修饰，将属性藏起来。并且由于重写了Pet中的方法，调用的eat与sleep方法是子类Cat中的返回值。Cat类继承Pet类，并且重写了Pet中的eat与sleep方法，
面向对象-封装继承多态
Ariel_欢
05-27 1124
一、什么是封装？请详细解释。主要封装哪些内容？ ①每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。这样方法和属性包装在类中，通过类的实例来实现。 ②封装：隐藏对象的属性和实现细节，仅对外公开接口，并控制在程序中属性的读和修改的访问级别。 封装：要有装更要有封：把对象的属性和方法装在类中，还得封起来（访问修饰符的权限问题） 二、什么是继承？继承的主要目的是什么？继承与实现之间有什么关系？ 1.继承定义了类如何相互关联，共享特性。 2.主要目的：为
Java之封装、继承，多态
weixin_74200123的博客
07-12 1037
详细的介绍了java中的三大特性，封装、继承、多态。
Java面向对象编程（封装/继承/多态）实例解析
08-29
在 Java 中，封装可以通过访问修饰符（public、private、protected 等）和 getter/setter 方法来实现。 在上面的代码中，可以看到 Teacher 和 Student 两个类的实现。这些类都具有封装的特征。例如，在 Teacher 类...
Java面向对象三大特性，即封装、继承、多态
12-23
@Java 面向对象三大特性知识模板 ...访问修饰符：private（可将属性修饰为私有，仅限本类可见） 公共访问方法 过滤有效数据 注意：外部访问只可以访问公共空间，不可以直接访问属性设置为privat
c++ 的封装继承多态例子
04-01
为了保护数据不被随意访问，我们可以设定访问修饰符如`public`、`private`和`protected`。`public`成员可以被任何代码访问，`private`成员只能在类内部访问，而`protected`成员可以被类及其子类访问。 **继承** 是...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 548
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1105
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 148
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 626
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 907
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 340
spirng security中的几大组件的差异和执行顺序
封装 继承 多态
07-27
- *3* [C++ 类的封装继承多态](https://blog.csdn.net/secondtonone1/article/details/124485035)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值