java笔记4 - 悦读

文章目录

六.面向对象编程（Object Orienteed Programing)
- 11.面向对象三大特征

六.面向对象编程（Object Orienteed Programing)

11.面向对象三大特征

继承、封装、多态

1.继承

a.使用 extends 实现继承

public class Test{
     public static void main(String[ ] args) {
 		Student s = new Student("KZY",180,"Java");
 		s.person.rest(); //s.rest();
 		s.study();
     } 
}
class Person {
 	String name;
 	int height;
 	public void rest(){
 	System.out.println("休息一会！");
 	}
}
class Student extends Person{
 	String major; //专业
    public void study(){
		System.out.println("在尚学堂，学习Java");
    }
 	public Student(String name,int height,String major) {
 		//拥有父类的对象，通过这个对象间接拥有它的属性和方法
 		this.person.name = name; //this.name = name;
 		this.person.height = height; //this.height = height;
 		this.person.rest();
 		this.major = major;
 	} 
}

b.instanceof 运算符

instanceof 是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象

时，返回 true；否则，返回 false。

代码如上。

c.继承使用要点

1.父类也称作超类、基类。子类：派生类等。

2.Java 中只有单继承，没有像 C++那样的多继承。多继承会引起混乱，使得继承链

过于复杂，系统难于维护。

3.Java 中类没有多继承，接口有多继承。

4. 子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见

得可以直接访问(比如，父类私有的属性和方法)。

5.如果定义一个类时，没有调用 extends，则它的父类是：java.lang.Object。

d.方法重写 override

方法重写需要符合下面的三个要点：

1.“= =”：方法名、形参列表相同。

2.“≤”：返回值类型和声明异常类型，子类小于等于父类。

3.“≥”：访问权限，子类大于等于父类。

方法重写

public class TestOverride {

	public static void main(String[ ] args) {

		Horse h = new Horse();

		Plane p = new Plane();

		h.run();

		h.getVehicle();

		p.run();

	} 

}

class Vehicle { //交通工具类

	public void run() {

		System.out.println("跑....");

	}

	public Vehicle getVehicle(){

		System.out.println("给你一个交通工具！");

		return null;

	} 

}

class Horse extends Vehicle { // 马也是交通工具

	@Override

	public void run() {

		System.out.println("得得得....");

	}

	@Override

	public Horse getVehicle() {

		return new Horse();

	} 

}

class Plane extends Vehicle {

	@Override

	public void run() {

		System.out.println("天上飞....");

	} 

}

final 关键字

e.final 关键字

final 关键字的作用：

修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final int MAX_SPEED = 120;

**修饰方法：**该方法不可被子类重写。但是可以被重载！

final void study(){}

修饰类: 修饰的类不能被继承。比如：Math、String 等。

final class A {}

f.继承和组合

组合比较灵活。继承只能有一个父类，但是组合可以有多个属性。

对于“is -a”关系建议使用继承，“has-a”关系建议使用组合。

比如：上面的例子，Student is a Person 这个逻辑没问题，但是：Student has a Person

就有问题了。这时候，显然继承关系比较合适。

再比如：笔记本和芯片的关系显然是“has-a”关系，使用组合更好。

public class Test{
	public static void main(String[ ] args) {
 	Student s = new Student("KZY",180,"Java");
 	s.person.rest(); //s.rest();
 	s.study();
 	} 
}
class Person {
 	String name;
 	int height;
 	public void rest(){
 		System.out.println("休息一会！");
 	} 
}
class Student /*extends Person*/ {
 	Person person = new Person();
 	String major; //专业
 	public Student(String name,int height,String major) {
 	//拥有父类的对象，通过这个对象间接拥有它的属性和方法
 		this.person.name = name; //this.name = name;
 		this.person.height = height; //this.height = height;
 		this.person.rest();
 		this.major = major;
 	} 
}

g.==和 equals 方法

“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地

址相等即是同一个对象。

equals() 提供定义“**对象内容相等”**的逻辑。比如，我们在公安系统中认为 id 相同的

人就是同一个人、学籍系统中认为学号相同的人就是同一个人。

equals()默认是比较两个对象的 hashcode (可以想象成地址）。但，可以根据自己的要求重写 equals 方法。

public class TestEquals { 
	public static void main(String[ ] args) {
		Person p1 = new Person(123,"KZY");
        Person p2 = new Person(123,"ZY");
		System.out.println(p1==p2); //false，不是同一个对象
        System.out.println(p1.equals(p2)); //true，重写后id相同则认为两个对象内容相同
        String s1 = new String("图书馆");
        String s2 = new String("图书馆");
        System.out.println(s1==s2); //false, 两个字符串不是同一个对象
        System.out.println(s1.equals(s2)); //true, 两个字符串内容相同
	} 
}
class Person {
	int id;
    String name;
    public Person(int id,String name) {
        this.id=id;
        this.name=name;
	}
	//重写equals方法
    public boolean equals(Object obj) {
    	if(obj == null){
   		 return false;
    	}else {
    		if(obj instanceof Person) {
    			Person c = (Person)obj;
    			if(c.id==this.id) {  			//自己要的要求
    				return true; 
        		}
        	}
    	}
    	return false; 
	}
}

h.super关键字

1.super“可以看做”是直接父类对象的引用。

2.可通过 super 来访问父类中被子类覆盖的方法或属性。使用 super 调用普通方法，语句没有位置限制，可以在子类中随便调用。

3.在一个类中，若是构造方法的第一行没有调用 super(…)或者 this(…); 那么 Java 默认都会调用 super(),含义是调用父类的无参数构造方法。

public class TestSuper01 { 
	public static void main(String[ ] args) {
	new ChildClass().f();
	}
}
class FatherClass {
     public int value;
     public void f(){
         value = 100;
         System.out.println ("FatherClass.value="+value);
     } 
}
class ChildClass extends FatherClass {
    public int value;
    public int age;
    public void f() {
         super.f(); //调用父类的普通方法
         value = 200;
         System.out.println("ChildClass.value="+value);
         System.out.println(value);
         System.out.println(super.value); //调用父类的成员变量
 	}
	public void f2() {
 		System.out.println(age);
    }
}

继承树追溯

属性/方法查找顺序：(比如：查找变量 h)

查找当前类中有没有属性 h
依次上溯每个父类，查看每个父类中是否有 h，直到 Object
如果没找到，则出现编译错误。
上面步骤，只要找到 h 变量，则这个过程终止。

· 构造方法调用顺序：

构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到 Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

**注：**静态初始化块调用顺序，与构造方法调用顺序一样，不再重复。

public class TestSuper02 { 
	public static void main(String[ ] args) {
		System.out.println("开始创建一个ChildClass对象......");
		new ChildClass();
	} 
}
class FatherClass {
	public FatherClass() {
		System.out.println("创建FatherClass");
	} 
}
class ChildClass extends FatherClass {
	public ChildClass() {
        //super();		//3.在一个类中，若是构造方法的第一行没有调用 super(...)或者 this(...); 那么 Java 默认都会调用 super(),含义是调用父类的						//无参数构造方法。
		System.out.println("创建ChildClass");
	} 
}

执行结果：开始创建一个ChildClass对象…

创建FatherClass

创建ChildClass

2.封装（encapsulation)

封装的理念：高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。

封装的实现—使用访问控制符

Java 中 4 种“访问控制符”分别为 private、default、protected、public。

【注】关于 protected 的两个细节：

若父类和子类在同一个包中，子类可访问父类的 protected 成员，也可访问父类对象的

protected 成员。

若子类和父类不在同一个包中，子类可访问父类的 protected 成员，不能访问父类对象

的 protected 成员

封装的使用细节

package opp.b;

public class User {
    private int id;
    private String name;
    private boolean man;

    public User(int id, String name, boolean man) {
        this.id = id;
        this.name = name;
        this.man = man;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public boolean isMan() {
        return man;
    }

    public void setMan(boolean man) {
        this.man = man;
    }
}

package opp.b;

public class Test {


    public static void main(String[] args) {
        User u=new User(9,"KZY",true);
        u.setId(100);
        u.setName("shuaiqi");
        u.setMan(true);

        System.out.println(u.getName());
        System.out.println(u.isMan());
    }
}

输出结果：shuaiqi

true

3.多态（polymorphism)

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。

多态的要点：

多态是方法的多态，不是属性的多态（多态与属性无关）。
多态的存在要有 3 个必要条件：继承，方法重写，父类引用指向子类对象。
父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

package opp.polymorphism;

public class Animal {
    public void shout(){
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪王！");
    }
    public void seeDoor(){
        System.out.println("看门中...");
    }
}
class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵！");
    }
}

package opp.polymorphism;

public class TestPoly {
    public static void main(String[] args) {
//        animalCry(new Dog());
//        animalCry(new Cat());
   // 编译类型（animal)      //运行时类型Dog（）
          Animal animal=new Dog();
          animal.shout();
         // animal.seeDoor();
    }
    static void animalCry(Animal a){    //Animals a=new Dog()
        System.out.println("TestPolm.animalCry");
        a.shout();  //可以出现多态
    }
}

输出结果：TestPolm.animalCry
汪汪王！
TestPolm.animalCry
喵喵喵！
汪汪王！

对象的转型(casting)

1.父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

2.向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。

这时，我们就需要进行类型的强制转换，我们称之为向下转型

package opp.polymorphism;

public class Animal {
    public void shout(){
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪王！");
    }
    public void seeDoor(){
        System.out.println("看门中...");
    }
}
class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵！");
    }
    public void catchMouse(){
        System.out.println("抓老鼠中");
    }
}

package opp.polymorphism;

public class TestPoly {
    public static void main(String[] args) {
        animalCry(new Dog());
        animalCry(new Cat());
   // 编译类型（animal)      //运行时类型Dog（）
          Animal animal=new Dog();
          animal.shout();
          Dog d=(Dog)animal;
          d.seeDoor();
          //编译不会报错。运行会报异常：ClassCastException
        //Cat c=(Cat)animal;
        if(animal instanceof Cat){
            Cat c=(Cat)animal;
            c.catchMouse();
        }
    }
    static void animalCry(Animal a){    //Animals a=new Dog()
        System.out.println("TestPolm.animalCry");
        a.shout();  //可以出现多态
    }
}