继承|重写|关键字super|关键字final|Object 类|多态

继承:

目的: 为了提高代码的复用性
类:对对象进行抽象,抽出像的部分
父类: 对一些类进行抽象,抽出像的部分

父类|超类|基类:被继承的类
子类|派生类: 继承父类的类

使用方法: 子类 extends 父类

继承的优点:
1.子类一旦继承父类,可以使用父类中的内容
2.子类是父类的延续+扩展
3.可以提高代码的复用性
单继承继承,一个子类只能继承一个父类,一个父类可以被多个子类继承,可以多实现

单继承的优点:
使用简单
单继承的缺点:
不便于后期维护

public class ExtendsDemo01 {
	public static void main(String[] args) {
		Student s=new Student();
		s.name="马云";
		s.age=30;
		s.study();
		s.sleep();
		
		Teacher t=new Teacher();
		t.name="zhangsan";
		t.age=20;
		t.teach();
		t.sleep();
	}
}

//抽取子类的共性定义父类
class Person{
	String name;
	int age;
	
	//休息
	public void sleep(){
		System.out.println(name+"休息...");
	}
}
//教师类
class Teacher extends Person{
	String subject;
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	
	//教学
	public void teach(){
		System.out.println(name+"教学..");
	}
	
}
//学生
class Student extends Person{
	int time;
	
	public Student() {
		
	}
	//学习
	public void study(){
		System.out.println(name+"学习..");
	}
}

权限修饰符

权限修饰符: 决定访问对象中成员的一个限定范围

				本类			 同包类			不同包子类			不同包其他类
  	public 			Y			Y					Y				Y
   protected		Y			Y					Y
   default(默认省略) Y			Y			
   private			Y

权限修饰符都是成员修饰符,修饰成员不能修饰局部
私有的内容能不能被继承
能够修饰类的修饰符只有2个,public ,default

• protected使用方式:

   		1.同包下的类
   		2.不同包下的子类,通过继承关系使用
   				如果在子类中的成员环境中使用,可以直接使用
   				如果在子类中的静态环境中使用,通过子类对象,在子类静态方法中使用
  

  开闭原则: 对修改关闭,对扩展开放,面向对象的设计原则之一

• 通过对象访问,就是访问成员的权限修饰符,看是否满足权限修饰符的权限要求

重写 和 重载的区别

重载和重写都是指方法
重载:
1)同一个类中,有多个方法
2)方法名相同
3)参数列表不同
重写:
1)不同的类
2)继承关系
3)方法签名相同

子父类中一旦存在方法的重写,在调用的时候,会调用子类中重写的方法,对父类的方法这个方法进 行屏蔽

如何检查一个方法是否为重写方法:
1.在这个重写的方法的上面添加一个注解 @Override
2.左侧会出现向上的三角形

• 注意:
  1.== 方法签名完全相同
  2.<= 返回值类型: 基本数据类型必须相同, 引用数据类型:子类重写方法的返回值类型<=父类中方法的返回值类型
  3.>= 权限修饰符: 子类重写方法的权限修饰符>=父类重写方法的权限修饰符

• 注意:
  1.被private修饰的方法不能被重写
  2.static修饰的方法不能被重写
  如果父类中有个同名的静态方法,子类中要定义这个名字的方法,必须也被static修饰
  3.被final修饰的方法不能被重写

什么时候定义方法的重写:
当子类需要父类中的某个功能,但是对父类中直接继承过来的功能体实现不满意,可以对父类中的方法进行重写,自定义方法体

public class OverrideDemo01 {
	public static void main(String[] args) {
		SiCong si=new SiCong();
		si.words();
		si.haha();
		
		JianLin jian=new JianLin();
		jian.words();
	}
}

class JianLin{
	JianLin words(){
		System.out.println("先定一个小目标,赚它一个亿...");
		return null;
	}
	
	static void haha(){
		System.out.println("哈哈哈");
	}
}
class SiCong extends JianLin{
	//就近原则
	@Override
	public  SiCong words(){
		haha();
		System.out.println("我不在乎我的朋友有钱没钱,因为都没我有钱...");
		return null;
	}
}

关键字super

super关键字 和this之间的区别:

this:指代当前 创建的对象
super:父类对象

 1)使用在构造器的首行,调用父类的构造器  super(参数列表)
	如果子类没有显示调用父类构造器,默认调用父类空构造
	如果子类构造器中有显示调用父类中的任何构造器,就不会再次默认调用空构造了
	this()和super()不能显示同时出现

 2)区分同名问题:同名变量|同名方法
	如果不存在子父类同名问题:父类有找父类 , 子类有找子类
	如果存在子父类同名问题: 默认找子类,因为就近原则,如果想要找父类同名成员,使用super.进行调用,因为super默认指代父类对象

创建对象的过程: 先父类后子类
先静态后成员

• this和super不能和static一起使用

   public class SuperDemo04 {
   	public static void main(String[] args) {
   		Zi zi=new Zi("haha");
   		zi.test();
   		System.out.println(zi);	
   	}
   }
   
   class Fu{
   	String name="张翠山";
   	
   	public Fu() {
   		System.out.println("我是父类空构造");
   	}
   	
   	public Fu(String name) {
   		System.out.println("我是父类带参构造");
   		this.name=name;
   	}
   }
   
   class Zi extends Fu{
   	String name="张无忌";
   	public Zi() {
   		//super("lllllll");
   		System.out.println("我是子类空构造");
   	}
   	public Zi(String str) {
   		//super();
   		this();
   		System.out.println("我是子类带参构造");
   	}
   	void test(){
   		String name="张三丰";
   		//父类对象在子类对象内存空间中,外部无法使用,只能通过子类对象使用
   		System.out.println(name+"-->"+this.name+"-->"+super.name);
   		System.out.println(this);
   	}
   }
  

关键字 final(最终的)

1.被final修饰的变量为常量
2.被final修饰的方法不能被重写
3.被final修饰的类不能被继承,太监类
4.如果final修饰的对象的地址,可以改变对象的成员,只要地址不变

 public class FinalDemo01 {
	final Fu fu=new Fu();
	public static void main(String[] args) {
		new FinalDemo01().test();
	}
	void test(){
		System.out.println(fu.haha);
		fu.haha=20;  //自定义类的对象地址永远不变
		System.out.println(fu.haha);
		//fu=new Fu();
	}
}
class Fu{
	int haha=10;
}
class Zi extends Fu{}

Object 类

老祖宗类 ,是java中所有类的父类

如果一个类没有显示继承其他类,默认继承自Object
java是单继承机制,如果一个类显示继承了其他类,但是它的父类|父类的父类…可能会继承Object

打印一个对象引用时候,默认调用对象的toString方法,打印对象的地址
不想打印对象地址,想要打印对象的基本信息(成员属性的值)

使用重写toString()实现:可以将对象的内容以字符串的形式展现

• equals()和 == 之间的区别

   ==:比较引用数据类型比较的是对象的地址值
   	equals比较对象内容
   		public boolean equals(Object obj) {
        		return (this == obj);
    		}
   默认还是比较对象地址,但是子类可以对其进行重写,使用对象比较内容而非地址
  

多态

面相对象的特性: 多态
一种事物的多种形态,多种变现形式

多态的最终体现: 父类引用指向子类对象
多态的前提:
- 类的继承
- 接口的实现

多态父类引用在去调用方法的时候,会调用子类中重写的方法
注意: 父类引用对于子类新增内容不可见

多态调用时候:
变量:
编译运行看类型|父类|左边
方法:
编译看类型,运行才找对象

多态如果没有方法的重写没有意义

public class Demo01 {
	public static void main(String[] args) {
		//Person p=new Person();
		//多态
		Person s=new Student();
		s.test();
		System.out.println(s.name);
		//s.hehe();
		//特点:在检查语法时候,引用s能否调用,要检查s的数据类型Person中是否存在你要调用的内容,如果有可以,没有没有报错
	}
}

class Person{
	String name="999";
	void test(){
		System.out.println("Person");
	}
}

class Student extends Person{
	//String name="123";
	void test(){
		System.out.println("Student");
	}
	void hehe(){
		System.out.println("hahahehe");
	}
}