Java自学笔记3

一、继承

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物，同理，波斯猫和巴厘猫继承自猫，而沙皮狗和斑点狗继承自狗。这些动物之间会形成一个继承体系，具体如下图所示。

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类可以自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。通过使用 extends 关键字让类与类之间产生继承关系。
例如：

 class B extedns A {  }

public class Test{
	//属性
	//方法
}

//extends 表示继承
public class TestA extends Test{
	//属性
	//方法
}

继承的好处：
1.实现了代码的重用，相同的代码不需要重复的编写。
2.子类继承父类，可以直接享受父类中已经封装好的属性以及方法，不需要再次开发。
3.子类可以根据自己的属性，封装自己特有的属性和方法。
继承的注意事项：
Java中只支持单继承。不直接支持多继承。

单继承：一个类只能有一个父类。类似于一个儿子只能有一个父亲。

多继承：一个子类可以有多个直接父类
Java支持多层(多重)继承

C继承B，B继承A时，就会出现一个继承体系。
示例：

class Test
{
	void show1(){}
}
 
 
class TestA extends Test
{
//	void show1(){}
	void show2(){}
}
class TestB extends Test
{
//	void show1(){}
	void show3(){}
}

实例：

class Person{
    String name;
    int age ;
}
class Student extends Person{
    void study(){
        System.out.println("student ..." + age);
    }
}
class teacher extends Person{
    void teach(){
        System.out.println("teacher ..." + age);
    }
}
class Test{
    public static void main(String[] args){
        Student s = new Student();
        s. name = "小李" ;
        s. age = 5;
        s.study();
        Teacher w = new Teacher();
        w. name = "小张" ;
        w. age = 10;
        w.teach();
    }
}

运行结果

student    5
teacher    10

二、方法的重写（override）：

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
重写的注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
2，静态只能覆盖静态，或被静态覆盖。
示例：

public class Father {
	public void test(){
		System.out.println("test");
	}
	class child extends Father{
		@Override
		public void test(){
		}
	}
}

将@Override注释去掉的话，编译器会默认创建了新的方法
实例

class Animal{
	//父类被重写的方法
	public void say(){
		System.out.println("动物的话......");
	}
		protected void a(){
		}
	public Number c(){
		return null;
	}
	private void d(){
		}
	public static void f(){
		}
	public void info(){
		}
}

class Dog extends Animal{
	@Override
	public void info() {
		}
	public static void f(){
		}
	@Override
	public Integer  c(){
		return null;
	}
	@Override
	public void a(){
		}
	
	//方法的重写
	@Override
	public void say(){
		System.out.println("你好");
	}
}
public class OverrideTest {
public static void main(String[] args) {
		Dog dog = new Dog();
		dog.say();
	}
}

三、Object类和toString方法的重写

Object类是所有类的父类，一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类。以下两种类的定义的最终效果是完全相同的：

class Person { }

class Person extends Object { }

示例：

private String name;
private int age;
public Test(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Test test = new Test("张三",18);
System.out.println(test);
}

结果：com.zhang.Test@2503dbd3

private String name;
@Override
public String toString() {
return "name='" + name ;
}
public Test(String name) {
this.name = name;
}
public static void main(String[] args) {
Test test = new Test("张三");

System.out.println(test);
}

结果：name='张三'

四、多态

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态存在的三个必要条件：
1.要有继承
2.要有重写
3.父类引用指向子类对象

多态实现方式：
1.普通类

 Testa =  new Testb new();

2.抽象类 Test 是父类抽象类

Test a = new Test b();

3.接口 Test是类 Testa 是接口

Testa sk = new Test() 

多态的特点：
变量：编译看父类
方法：运行看子类