Java(三)面向对象的特性

构造方法生成小技巧：使用idea时，在代码空白处单击右键，选择Generate选项，之后再选择Constructor生成构造器，也可以使用toString()来重写这个函数。

继承

父类也称为超类、基类、派生类等
Java中只有单继承，没有像C++那样的多继承，多继承会引起混乱，使得继承过于复杂，系统难于维护
Java中没有多继承，但接口有多继承
子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如：父类私有属性和方法）
如果定义一个类时，没有调用extends，则它的父类是:java.lang.Objetct

package cn.yhq.oo; //非注释语句第一句public class User {public static void main(String[] args) {Student stu1 = new Student(20,"自动化","yhq","体育课");stu1.learning();stu1.showMajor();}
}
class Person{int age;String name;String major;
//父类中不能含有参构造，如果要继承的话
//    Person(int age,String name,String major){
//        this.name = name;
//        this.age = age;
//        this.major = major;
//    }public void showMajor(){System.out.println("我的专业是"+major);}
}
class Student extends Person{String lesson;public Student(int age,String major,String name,String lesson){this.major = major;this.name = name;this.age = age;this.lesson = lesson;}public void learning(){System.out.println("我在上课呢"+name+lesson);}
}

可以使用idea的功能可以方便查看类的继承结构

`instanceof`方法

使用instanceof可以判断对象是否归属于某个类：

Student stu1 = new Student(20,"自动化","yhq","体育课");System.out.println(stu1 instanceof Person);System.out.println(stu1 instanceof Object);System.out.println(new Person() instanceof Object);

方法重写(override)

子类通过重写父类的方法，可以使用自身的行为替换父类的行为。方法重写需要符合下面三个要点：

“==“:方法名、形参列表相同
“<=”:返回值类型和声明异常类型，子类小于等于父类
”>=“：访问权限，子类大于等于父类

class Vehicle{int speed;public void showTheType(){System.out.println("嗡嗡嗡");}public Person whoIsPsg(){//父类类型为Person，子类的类型要小于Personreturn new Person();}
}
class Horse extends Vehicle{public void showTheType() {System.out.println("马叫");}public Vehicle method(){return new Vehicle();}public Person whoIsPsg(){ //返回值类型小于父类的类型,如果是Object就会报错return new Student();}
}

Object类

object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。其中toString()是用于返回以一个字符串表示的对象值，是一种自我描述的方法，一般通过重写来打印所需要的内容。

public class TestObject {public static void main(String[] args) {TestObject to = new TestObject();System.out.println(to.toString());Person2 p2 = new Person2("喜喜",6);System.out.println(p2.toString());}public String toString(){ return "Test Obeject 对象";}}
class Person2{String name;int age;public String toString(){ return name+"年龄"+age;}public Person2(String name,int age){this.name = name;this.age = age;}}

`==`和equals方法

==代表比较双方是否相同，如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

Object类中定义有：public boolean equals(Object obj)方法，提供定义"对象内容相等"的逻辑。equals的源代码为：

    public boolean equals(Object obj) {return (this == obj);}

重写equals代码：

package cn.yhq.oo;import java.util.Objects;public class TestEquals {public static void main(String[] args) {Object obj;String str;User03 u1 = new User03("yhq","123456");User03 u2 = new User03("yhq","123456");System.out.println(u1==u2);//这表示不是同一个对象，结果为falseSystem.out.println(u1.equals(u2));//判断两个对象是否相同时吗，通常是判断其id是否相同}
}
class User03{String username;String pwd;public User03(String username, String pwd) {this.username = username;this.pwd = pwd;}public String toString() {return "User03{" +"username='" + username + '\'' +", pwd='" + pwd + '\'' +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;User03 user03 = (User03) o;return Objects.equals(username, user03.username);}}

super关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。构造方法的第一句总是：super(…)来调用父类对应的构造方法。所以流程是：

1.先向上追溯到Object

2.然后再依次向下执行类的初始化块和构造方法

3.执行到当前子类位置

静态初始化块调用顺序和构造方法调用顺序一致，不再重复

package cn.yhq.oo;public class TestSuper {public static void main(String[] args) {SonClass son = new SonClass();son.work();son.superWork();}
}
class FatherClass{String name;int age;FatherClass(){System.out.println("fatherClass");}void work(){System.out.println("father work");}
}
class SonClass extends FatherClass{//每个类的第一句话都是super(),自动调用父类的构造函数SonClass(){System.out.println("SonClass");}void work(){System.out.println("Son work");}void superWork(){super.work();}
}

封装

类的定义规则

1.一般使用private访问权限。

2.提供相应的set、get方法来访问相关的属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作。

3.一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

package Test;//成员变量全部换位public
public class Person4 {private int id;private String name;private int age;private boolean man;public void setName(String name){this.name = name;}public String getName(){return this.name;}public void setAge(int age){if (age>=1&&age<=130){this.age = age;}else {System.out.println("请输入正常年龄");}}
}

类中只包含set和get方法，这种类称为JavaBean,一个类中除了set和get之外的方法，一般都是用public，除了写包时候。

多态(polymorphism)

多态指的是同一个方法的调用，由于对象不同可能会有不同的行为，现实生活中，同一个方法，具体实现会完全不同。

多态是指方法的多态

多态的要点：

1.多态是方法的多态，不是属性的多态(多态和属性无关)。

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

3.父类引用指向子类对象后，用该父类引用调用子类重写方法，此时多态就出现了。

package Test;public class TestPoly {public static void main(String[] args) {Animal a = new Animal();animalCry(a);//父类对象指向子类Dog d = new Dog();animalCry(d);Cat c = new Cat();animalCry(c);}static void animalCry(Animal a){ //传入不同对象执行方法不同a.shout();}}
class Animal{public void shout(){System.out.println("叫了一声！");}
}
class Dog extends Animal{public void shout(){System.out.println("旺旺");}
}
class Cat extends Animal{@Overridepublic void shout() {System.out.println("喵喵");}
}

自动向下转型

Animal d = new Dog();   //自动向上转型：dog转成animal类，这里要注意类型是animal类，但是对象是Dog。
Dog d2 = (Dog)d;   //强制向下转型：animal转为dog//猫强转成dog,会产生编译错误
Animal c = new Cat();
Dog d3 = (Dog)c;

final修饰

final关键字作用：

1.修饰变量：被修饰得变量不可以改变，一旦赋值，就不能重新赋值。

final int MAX_SIZE = 120;

2.修饰方法：该方法不可被子类重写，但是可以被重载！

final void study(){}

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

final class A{}

数组（也为对象）

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称为一个元素，每个元素可以通过一个索引来访问。

特点

长度是确定的，数组一旦被创建，它的大小就是不可改变的
其元素必须是相同的，不允许出现混合类型
数组类型可以是任何数据类型，包括基本类型和引用类型

数组变量属于引用类型，数组也属于对象，数组中每个元素相当于该对象的成员变量。

声明方式

type[] arr_name;//推荐使用这种方式

注意事项

声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
声明一个数组的时候并没有数组真正被创建
构造一个数组，必须指定长度

package cn.yhq.array;public class Test01 {public static void main(String[] args) {//int[] arr01:这是数组的声明，int[] arr01 = new int[10];这是数组的初始化int[] arr01 = new int[10]; //索引下标[0 length-1]:String[] arr02 = new String[5];User[] arr03 = new User[3];arr03[0] = new User(100,"yhq"); //不是将对象直接放到数组，是存放对象地址arr03[1] = new User(101,"tony");arr03[2] = new User(102,"jenny");for (int i = 0;i<arr03.length;i++){System.out.println(arr03[i].getAge());}}
}
class User{private int id;private  String age;public User(int id, String age) {this.id = id;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}
}

不是将元素对象直接放到数组，是存放对象地址

初始化方式

静态初始化
动态初始化
默认初始化

package cn.yhq.array;public class Test02 {public static void main(String[] args) {//静态初始化int[] a = {2,3,4};User[] user01 = {new User(100,"19"),new User(101,"20")};//默认初始化int[] b = new int[3];//默认给数组的元素进行赋值。赋值的规则和成员变量赋值的规则一样//动态初始化int[] a1 = new int[2];//动态初始化数组，先分配空间a1[0] = 1;//给数组元素赋值a1[1] = 2;}
}

数组遍历

增强for循环for-each是专门用于读取数组或者集合中所有的元素，即对数组进行遍历。

 //foreach循环：用于读取数组元素的值，不能修改元素的值for (int m:num_array){System.out.println(m);}