活动地址：[CSDN21天学习挑战赛](https://marketing.csdn.net/p/bdabfb52c5d56532133df2adc1a728fd)

---

前言

【回顾上节】
类的方法
方法是类和对象动态行为特征的抽象。

java对象的创建和使用：

1. 必须使用 new 关键字创建对象。
   Person person= new Person ();
2. 使用对象（引用） . 成员变量来引用对象的成员变量。
   person.age
3. 使用对象（引用） . 方法（参数列表）来调用对象的方法。
   setAge(23)
   类中就是：//静态的数据 //动态的行为

JAVA程序运行的内存分析
栈 stack：

   1. 每个线程私有，不能实现线程间的共享！
   2. 局部变量放置于栈中。
   3. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！
1
2
3

堆 heap：

    1. 放置new出来的对象！
    2. 堆是一个不连续的内存空间，分配灵活，速度慢！
1
2

方法区(也是堆)：

4. 被所有线程共享！
5. 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）
1
2

一、 封装

我们程序设计要追求“高内聚，低耦合”。
高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴露少量的方法给外部使用

封装简单理解就是数据的隐藏。有必要决定这些特性的可见性，即哪些特性对外部 可见的，哪些特性
用于表示内部状态。

封装步骤

1. 使用private修饰要封装的成员变量。
2. 提供一个公开的方法设置或者访问私有的属性
   1. 设置set方法，命名格式set属性名（）；属性名需要大写。
   2. 访问通过get方法，命名格式：get属性名（）；属性的首字母要大写。
   【演示】对象能访问public定义的内部；

//对象能在类的外部"直接"访问 
public class Student{
	 public String name; 
	 public void println(){
	  System.out.println(this.name);
	   }
 }
public class Test{
	 public static void main(String[] args){ 
	 Student s = new Student();
	  s.name = "tom";  } }
================================
//如果使用private关键字把数据隐藏起来，外部不能直接访问
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.name = "tom";
   
   //那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性
	s.setName("tom"); 
	System.out.println(s.getName());
   } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

意义和作用

1. 提高程序的安全性，保护数据。
2. 隐藏代码的实现细节
3. 统一用户的调用接口
4. 提高系统的可维护性
5. 便于调用者调用。

良好的封装，便于修改内部代码，提高可维护性。
良好的封装，可进行数据完整性检测，保证数据的有效性。

方法重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载
方法重载必须满足以下条件

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

public class Test{ 
	public void test(String str){ }
	public void test(int a){ }

	public void test(Strig str,double d){}  
	public void test(Strig str){}

	public void test(Strig str,double d){}  
	public void test(double d,Strig str){}
 }
 
1
2
3
4
5
6
7
8
9
10
11

二、继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性。
extands的意思是“扩展”。子类是父类的扩展。

1. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
2. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
3. 类和类之间的继承是单继承

一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲 
一个父类可以被多子类继承,就像一个父亲可以有多个孩子
1
2

4. 父类中的属性和方法可以被子类继承
   子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。

父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
1
2

super关键字

父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用
super关键字)。
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法, 使用super就表示访问或调用父类中的属性和方法。
【访问父类中的属性】

public class Person{
  protected String name = "zs";
  }
 public class Student extends Person{ 
   private String name = "lisi"; 
   public void tes(String name)t{ 
   System.out.println(name); //zs
   System.out.println(this.name); //lisi
   System.out.println(super.name); //zs
   } }
1
2
3
4
5
6
7
8
9
10

【调用父类中的方法】

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(); //Student
			  this.print();//Student
			 super.print(); //Person
} }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

【调用父类中的构造器】

public class Person{
//编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器 
/*
	protected String name; 
	public Person(String name){ 
	this.name = name; 
}
*/
}
public class Student extends Person{
 //编译通过,子类构造器中会隐式的调用父类的无参构造器 
 //super(); 
 public Student(){ }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

【显式的调用父类的有参构造器】

public class Person{ 
	protected String name; 
	public Person(String name){
	 this.name = name; } }
 public class Student extends Person{
  //编译通过,子类构造器中显式的调用父类的有参构造器 
  public Student(){ super("tom");
 } }
1
2
3
4
5
6
7
8

不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

public class Person{ 
protected String name; 
public Person(String name){
   this.name = name; 
 } }
 //编译通过
  public class Student extends Person{ 
  private int age;
   public Student(){
     this(20); }
    public Student(int age){
     super("tom"); 
     this.age = age;
      } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

3.Object类

java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is a
Object。
例如:toString方法、equals方法、getClass方法等

System.out.println(任何对象 instanceof Object); 
//输出结果:true //注:任何对象也包含数组对象
1
2
3

4. 方法重写

1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不
   能被重写

2. 静态方法不能重写
   1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
   2. 父类的非静态方法不能被子类重写为静态方 法；//编译出错
   3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

A类继承B类 A和B中都一个相同的静态方法test
 B a = new A(); a.test();
 //调用到的是B类中的静态方法
 test A a = new A(); 
 a.test();
 //调用到的是A类中的静态方法test
  可以看出静态方法的调用只和变量声明的类型相关 这个和非静态方法的重写之后的效果完全不同
1
2
3
4
5
6
7

1. 私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。

public class Person{ 
private void run(){} }//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法 
public class Student extends Person{
 private void run(){} 
 }
1
2
3
4
5
6

方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <
public，friendly < public)

4.多态

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。
允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

相同类域的不同对象,调用相同的方法,执行结果是不同的

1. 一个对象的实际类型是确定的
   例如: new Student(); new Person();等
2. 可以指向对象的引用的类型有很多
   例如: Student继承了Person类

Student s1 = new Student();
 Person s2 = new Student(); 
 Object s3 = new Student();
1
2
3

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

调用到的run方法,是Student从Person继承过来的run方法

public class Person{ 
   public void run(){} 
}
public class Student extends Person{
   public void run(){ //重写run方法 }
  }
 //调用到的run方法,是Student中重写的run方法
  main:
   Person p = new Student();
   p.run();
1
2
3
4
5
6
7
8
9
10

重写、重载和多态的关系
重载是编译时多态
重写是运行时多态
多态是方法的多态，属性没有多态性。

多态存在的条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：
4. static方法，因为被static修饰的方法是属于类的，而不是属于实例的
5. final方法，因为被final修饰的方法无法被子类重写
6. private方法和protected方法，前者是因为private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢。

：）创作不易，轻动手指来一个三连吧~