JAVA面向对象

面向对象：

所谓对象就是对事物存在的实体。对象一般被分为两个部分，一个是 “属性” 另一个是 “实体”。
如果拿一个人举例，所谓属性指的是：身高、体重等，而对象就是一个人体重、身高的数值。

1.0

1.1 类的创建

class 类名{
	属性类型 成员变量名；
	......
	修饰符 返回值类型 方法名（参数）{
		具体方法
	}
}

---

1.2 对象的创建

类名 对象名 = new 类名（）；

对象的创建的实质就是在内存中开辟一片内存，对其进行处理；

---

1.3 构造器

• 构造方法名与类名相同
• 构造器没有返回值
• 构造器可以重载

class Person{
	String name;
	int age;
	//以下为构造器
	public Person(){	//这是无参构造器
	}
	//以下为重载重载
	public Person(String name){		//这是重载
		this.name = name;
	}
	public Person(String name, int age){		//这也是重载
		this.name = name;
		this.age = age;
	}
}

---

1.4 static 关键字

static关键字表示静态的

1.4.1静态变量

例子：对象创建计数

class People{
	static int count; 	//默认值为0
	//在构造器中对静态变量 count 进行自加，每次调用构造器都能时 count 自增，来统计创建了多少个 People 类
	public People(){
		count++;
	}
}

public static void main(String[] args){
	Person p1 = new Person;
	Person p2 = new Person;
	Syetem.out,println(count);
	//此处输出值为  2
}

注意：static 不能修饰方法中的局部变量

1.4.2 静态方法

使用 static 修饰的方法，称为静态方法，无需创建类的实例就能调用

class Person{
    static int count;
    public Person(){
        count++;
    }
    public static void say(){
        System.out.println("类实例化次数：" + count);
    }
}

public class StaticFunction {
    public static void main(String[] args) {
        Person.say();                   //调用静态方法
        Person p1 = new Person();
        Person p2 = new Person();
        Person p3 = new Person();
        Person p4 = new Person();
        Person.say();                   //调用静态方法
    }
}

结果：
类实例化次数：0
类实例化次数：4

进程已结束，退出代码为 0

注意：静态方法不能访问实例变量（类中的未定义变量），因为实例变量必须在对象开辟内存（成为对象的变量）后才能被访问。

---

1.5 代码块

普通代码块：

由大括号 “ {} ” 括起来的代码。

public class TestBlock {
    public static void main(String[] args) {
        int a = 2;
        System.out.println(a);
        
        {
            int b = 1;
            System.out.println(b);
        }
    }
}


结果：
2
1

进程已结束，退出代码为 0

构造代码块：
构造代码块就是直接定义在类中的代码块，构造代码块在创建对象时就被调用（在构造方法之前），因此可以用来初始化成员变量。

class Person{
    public Person() {
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块");
    }
}

public class TestBlock {
    public static void main(String[] args) {
        new Person();
        new Person();
        new Person();
    }
}
结果：
构造代码块
构造方法
构造代码块
构造方法
构造代码块
构造方法

进程已结束，退出代码为 0

静态代码块：
静态代码块是最早被执行的代码，但是只会被执行一次（写在主方法外面）

class Person{
    public Person() {
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块");
    }
}



public class TestBlock {
    public static void main(String[] args) {
        new Person();
        {
            int b = 1;
            System.out.println(b);
        }
    }
        static{
            System.out.println("这是静态代码块");
        }

}
结果：
这是静态代码块
构造代码块
构造方法
1

进程已结束，退出代码为 0

---

1.6 内部类

---

2.0

2.1 类的继承

继承就是指创建子类拥有父类的全部属性

class 子类名 extends 父类名{

}

注：java不支持多继承，但是它支持多层继承，即一个类的父类可以继承别的类。

2.2类的重写

1.在继承关系中，子类可以重新定义父类中已经存在的方法，形式如下：

//定义一个父类
class Father{
    void say(){
        System.out.println("这是父类");
    }
}
//定义一个继承父类的子类
class Son extends Father{
    void say(){
        System.out.println("这是子类");
    }
}

public class TestOverride {
    public static void main(String[] args) {
        //new一个子类，调用子类say()方法
        Son son = new Son();
        son.say();
        //new一个父类，调用父类say()方法
        Father father = new Father();
        father.say();
    }
}
/*结果：

这是子类
这是父类

进程已结束，退出代码为 0

*/

2.super
当子类重写父类方法后，子类对象无法访问父类方法，如果需要访问父类方法，需用 “super" 关键字。

class Father{
    String name = "父类";
     public void say(){
        System.out.println(name);
    }
}

class Son extends Father{

     public void say(){
        String name =super.name;
        super.say();
        System.out.println("名：" + name);
     }

}

public class TestSuper {
    public static void main(String[] args) {
        Son son = new Son();
        son.say();
        
    }
}
/*结果：

父类
名：父类

进程已结束，退出代码为 0

*/

2.3final

在Java中，某些类可以被设置为不允许继承，final修饰的类、方法和变量有一下特性：
final修饰的类不能被继承；
final修饰的方法贝能被子类重写；
final修饰的变量事常量，初始化后不能被修改。

2.4抽象类和接口

1.抽象类

java中可以定义不含方法体的方法，方法的方法体可以由该类的子类根据实际需求去实现，这样的方法被称为抽象方法，包含抽象方法的类必须是抽象类。
Java中用abstract关键字修饰的方法为抽象方法，是一个不完整的方法，只有方法声明，没有方法体。
使用抽象方法时要注意，抽象类不能被实例化（不能new），因为其没有方法体，知识一个声明，不能被调用，所以必须通过子类继承的方法来定义抽象类的方法体。

abstract class Parent{
	//abstract修饰的方法不需要方法体
    public abstract void say();
}
	//继承了抽象类的具体子类，必须实例抽象父类中的所有方法
class Child extends Parent{
    public void say(){
        System.out.println("hi");
    }
}

public class TestAbstractClass {
    public static void main(String[] args) {
        Child child = new Child();
        child.say();
    }
}
/*结果：

hi

进程已结束，退出代码为 0


*/

注意：（1）继承了抽象类的具体子类，必须实例抽象父类中的所有方法，否则此类必须为抽象类。
（2）抽象方法不能用static来修饰；
（3）抽象方法也不能用final来修饰；
（4）抽象方法不能用private修饰。

抽象类的构造器：

//抽象类的定义
abstract class Parent{
    private String name;

    public Parent() {
        System.out.println("抽象类的无参构造器");
    }

    public Parent(String name) {
        this.name = name;
        System.out.println("抽象类的有参构造器");
    }
}

//继承抽象类的方法
class Child extends Parent{
    public Child() {
        System.out.println("实例类的无参构造");
    }

    public Child(String name) {
        super(name);
        System.out.println("实例类的有参构造");
    }
}

public class TestAbstractConstructor {
    public static void main(String[] args) {
        new Child();
        new Child("！！");
    }
}
/*结果：

抽象类的无参构造器
实例类的无参构造
抽象类的有参构造器
实例类的有参构造

进程已结束，退出代码为 0

*/

2.接口

接口是全局常量和公共抽象类的集合，接口可被看作一种特殊的类，属于引用类型，使用iterface关键字可以声明接口。

在接口中定义的变量均为全局常量，方法均为抽象方法：

interface S{
	Sring name;		//相当于public static final String name;
	void say();		//相当于public abstract void say();
}

接口的实现：
因为接口中有抽象方法，所以不能被实例化，可以使用implements关键字实现多个接口：

//定义接口
interface Parent{
    void say();
}

interface People{
    void work();
}

//实例化接口
class Child implements Parent,People{
    public void say(){
        System.out.println("hello");
    }
    public void work(){
        System.out.println("工作中");
    }
}

public class TestImplements {
    public static void main(String[] args) {
        Child child = new Child();
        child.say();
        child.work();
    }
}
/*结果：

hello
工作中

进程已结束，退出代码为 0

*/

接口之间也可以相互继承。在实例化某一接口时，要实例化其自身加上继承的所有的抽象方法。

3.抽象类和接口的关系
相同点：

• 都包含抽象方法
• 都不能被实例化
• 都是引用类型

不同点较多，不一 一列举。

3.0多态

多态是面向对象的里能以大特征，封装和继承是为实现多态做准备的。简单的说，堕胎是具有变现多种形态的能力特征，它可以提高程序的抽象程度和简洁性，最大程度地降低了类和程序模块间的耦合性。

//定义一个People类
class People{
    void sing(){
        System.out.println("singPeople");
    }
}
//定义一个Person类，继承People类
class Person extends People{
    void sing(){
        System.out.println("singPerson");
    }
}
//定义一个Li类，继承Person类
class Li extends Person{
    void sing(){
        System.out.println("singLi");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        //新建一个Person对象，使用其sing方法
        new Person().sing();
        //定义Person类型引用变量
        People p = null;
        //使用Person类型引用变量引用People对象
        p = new People();
        p.sing();
        //使用Person类型饮用方法引用Li对象
        p = new Li();
        p.sing();
    }
}
/*结果：

singPerson
singPeople
singLi

进程已结束，退出代码为 0

*/

java中的引用变量有两种类型，即声明类型和实际类型。变量声明时被指定的类型为声明类型，而被变量引用的对象类型为实际类型。方法可以在沿着继承链的多个类中实现，当调用实例方法时，java虚拟机会调用相对应的实际类型的方法。

instanceof方法：
java中可以用instanceof方法判断一个类（或者接口）的实例，返回Boolean值。

Person p = new Child();
System.out.println(p instanceof Parent);
System.out.println(p instanceof Child);

4.0 Object类

Java中提供一个Object类，是所有类的父类，即所有的类都继承Object类。
Object有方法：

• public String toString() 返回描述该对象的字符串
• public Boolean equals(Object o) 比较两个对象是否相等；例子： o1.equals(02); //o1、o2都是对象
• pub int hashCode() 返回对象的哈希值