--面向对象--

对象

万物皆对象，对象有自己的特征（即属性），也可以定义自己的行为（方法）。

局部变量与实例变量
实例变量

定义在类里面，本身有初始值，为null。

局部变量

需要赋初始值才可以访问，作用于方法体内部，方法执行完销毁。

方法重载

• 方法名称相同。
• 参数列表不同(类型、个数、顺序)。
• 与访问修饰符、返回值类型无关。

 public int add(int a, int b) {

        int result = a + b;
        return result;
    }

    public int add(int a, int b, int c) {

        int result = a + b + c;
        return result;
    }

成员内部类

在类中再建立一个类 ，就叫内部类。如需在其他类中访问，需要加关键字public
内部类访问方法
Outer.Inner inner = new Outer().new Inner();
inner.show();

============访问外部类的实例变量
张三
19
============访问内部类的实例变量
李四
18

public class Outer {

    String name = "张三";
    int age =19;
    //创建内部类
    public class Inner{
        String name = "李四";
        int age =18;

        //创建内部类的方法
       public void show(){
           System.out.println("=======访问外部类======");
           System.out.println(Outer.this.name);
           System.out.println(Outer.this.age);
           System.out.println("=====访问内部类=======");
           System.out.println(name);
           System.out.println(age);

       }
    }
}

Object 重写equal方法

• 比较两个引用是否指向同一个对象。
• 判断obj是否为null。
• 判断两个引用指向的实际对象类型是否一致。
• 强制类型转换。
• 依次比较各个属性值是否相同。

@Override
	public boolean equals(Object obj) {
		//1判断两个对象是否是同一个引用
		if(this==obj) {
			return true;
		}
		//2判断obj是否null
		if(obj==null) {
			return false;
		}
		//3判断是否是同一个类型
//		if(this.getClass()==obj.getClass()) {
//			
//		}
		//intanceof 判断对象是否是某种类型
		//转student类型
		if(obj instanceof Student) {
			//4强制类型转换
			Student s=(Student)obj;
			//判断是否相等，然后返回true/false
			if(this.name.equals(s.getName())&&this.age==s.getAge()) {
				return true;
			}
			
		}
		return false;
	}

构造方法和this关键字

类中的特殊方法，主要用于对象的创建。
特点：
没有返回值，名称和类名称一致。

对象创建的过程：

• 内存中开辟对象空间
• 为各个属性赋予初始值
• 执行构造方法中的代码
• [将对象的地址赋值给变量]

this关键字
cat类

    public String name;
    public String color;

    public void eat(){
        String name ="jerry";
        String clolr = "绿色";

        //加了this取到的就是实例变量
        System.out.println(this.color+"的"+this.name+"小猫在吃鱼");
        System.out.println("没有加this关键字:");
        //取到的是否赋值了的成员变量
        System.out.println(clolr+"的"+name+"小猫在吃鱼");
        play();
        sleep();
    }
    public void play(){

        System.out.println("猫在玩游戏");
    }
    public void sleep(){
        System.out.println("猫在睡觉");
    }

cattest类

 Cat cat = new Cat();
        cat.name = "tom";
        cat.color = "黄色";
        cat.eat();      

输出：
黄色的tom小猫在吃鱼
没有加this关键字:
绿色的jerry小猫在吃鱼
猫在玩游戏
猫在睡觉

类的三大特性
1.封装
类的属性私有化，在外部仅能通过属性的get set方法对其进行操作（设置值，获取值）。
2.继承
父类的属性方法可以继承给到子类，子类可以访问父类的属性和方法（private关键字修饰的属性和类除外）,子类也可以根据实际需求重写父类的方法（super关键字可以继承到父类方法的方法体）。

super关键字的作用

1.继承父类的方法，相当于调用了父类的相同的方法，添加在子类的方法中。
2.super可访问父类属性
3.继承父类的无参构造方法

方法的重写

1.方法名称、参数列表、返回值类型必须与父类相同。
2.访问修饰符可与父类相同或是比父类更宽泛。
方法重写的执行：
子类重写父类方法后，调用时优先执行子类重写后的方法。
注意：重写和重载是两个完全不同的概念

3.多态

两个类子在有继承关系的基础上，父类引用可指向子类对象，即形成多态。
上代码，具体实现及其main方法如下
定义乐器类Instrument，包括方法makeSound()
定义乐器类的子类：二胡Erhu、钢琴Piano和小提琴Violin
定义乐手类Musician，可以弹奏各种乐器play(Instrument i)
定义测试类，给乐手不同的乐器让他弹奏

Musician musician = new Musician();
        //new 一个Fiddle  让演奏者弹奏二胡
        Fiddle fiddle = new Fiddle();
        fiddle.name="二胡";
        //new 一个piano  让演奏者弹奏钢琴
        Piano piano = new Piano();
        piano.name="钢琴";
        //多态，形参类型为父类，调用时的调用参数可以为其他的任何子类类型
        musician.play(fiddle);
        musician.play(piano);

        System.out.println("=================");
        //装箱, 把piano赋值给Instrument对象,装箱后的Instrument对象
        //转换之后，只能访问父类本身的属性和方法（**特例**如果子类有重写父类的方法，优先访问子类重写父类的方法。）
        Piano piano2 = new Piano();
        Instrument instrument = piano2;
        System.out.println(instrument.name);
        //只能访问父类的方法
        instrument.makeSound();
        //拆箱 ,将装箱后的instrument拆成Piano对象，强转类型
        Piano piano1= (Piano) instrument;
        //子类未定义，访问父类的属性和方法
        System.out.println(piano1.name);
        //拆箱之后,可以继续访问子类的特有方法
        piano1.vocalization();

    >Instrument类如下

String name = "乐器";

    //演奏
   void makeSound() {
       System.out.println("弹奏乐器");
    }

Musician类如下

public class Musician {


    void play(Instrument i){
        System.out.println("弹奏"+i.name);
    }
}

输出------
弹奏二胡
弹奏钢琴

========
乐器
弹奏乐器
乐器
我是钢琴，我的声音很清澈

抽象类
没有具体实现的类，不能实例化。

1.抽象类需加上abstract关键字
2.抽象类中可以定义抽象方法，抽象方法没有方法体,且子类如果继承了抽象类，必须实现抽象方法
3.抽象类没有具体实现

接口
特殊的一个抽象类

1.定义一个接口需加上interface关键字。
2.实现接口必须实现接口中的所有抽象方法。
3.接口中的变量和方法都是用public修饰的，也称公共静态常量（public static final），公共抽象方法（public abstract）。
4.一个类可以实现多个接口，implements中间用‘，’隔开。
5.接口与接口是可以多继承的（一个接口可以有多个父类）。extends 父接口1 , 父接口2 , 父接口n

static关键字

修饰类属性和方法，被修饰的属性和方法称为静态属性和静态方法。
被static修饰的属性和方法不用创建对象可通过类名直接访问。

特点

静态方法可以直接访问静态属性和方法。不能直接访问非静态成员
静态方法中不允许使用this和super关键字。

静态代码块 和非静态代码块

static{
//静态代码块
}
{
//非静态代码块
}

区别

静态代码块在类创建之前执行，也就是在new 对象之前执行。而普通代码块要在类加载之后才执行，也就是new对象之后执行。