Java_Day_12_Object_总结

final修饰符，表示最终，不可更改
fina|修饰的类不能被继承，
修饰的成员方法不能被复写，
修饰的变量不能二次赋值，没有默认值，必须显试赋值
final修饰的静态变量也就是| public final static 数据类型变量名=值;
 

public class Final_01 {
	public static void main(String[] args) {
		final Customer customer = new Customer("张三", 18);
		// customer 表示的是 接收到的堆内存的地址，被final修饰地址不能变，地址内的内容可变
		System.out.print(A.i);
	}
}

// 无法被继承
class A {
	// 无默认值，不能修改,被称为常量
	public static final int i = 1;

	// 无法覆写
	public final void m() {
		// 无法二次赋值
		final int i = 1;
	}
class Customer {
	String nameString;
	int age;

	public Customer(String nameString, int age) {
		super();
		this.nameString = nameString;
		this.age = age;
	}

多态
父类引用指向子类对象
父类引用:指的是用父类型声明的引用类型变量
指向:通过内存地址可以找到哪个对象
子类对象:new子类创建的堆内存对象
子类变量=new子类();
Catc=newCat();
父类类型变量名=new子类0;
Animal a = new Cat() ;
同一“操作,作用于不同对象，可以有不同的解释产生不同的结果,这就是多态性
优点:当一件事会有多种不同实现方式的时候,我们选择依赖高层，来拥抱多种变化
本质还是降低类和细节之间的耦合度

缺点:丢失子类特有的属性
多态进行属性调用:
父类没有，直接报错，不管子类有没有
父类有，子类没有，调用父类
父类有，子类有，调用子类
多态原因，子类特有属性访问不到，访问要强制类型转换，向下转型
必须向_上后再向下.
 

public class DuoTai_01 {
	public static void main(String[] args) {
		// 多态pet

		// 父类有，子类有，调用子类
		pet(new Dog());
		pet(new Cat());

		// 调用父类
		pet(new Animal());

		// 父类有，子类没有，调用父类
		pet(new Tiger());

		// // 父类没有，直接报错，不管子类有没有
		// Animal pigAnimal = new Pig();
		// pigAnimal.take();

		// 多态代码
		Animal a = new Dog();
		pet(a);
	}

	public static void pet(Animal animal) {
		animal.eat();
	}
}

class Animal {
	public void eat() {
		System.out.println("吃东西");
	}
}

class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗吃东西");
	}
}

class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃东西");
	}
}

class Tiger extends Animal {

}

class Pig extends Animal {
	public void take() {
		System.out.println("猪说话");
	}
}

判断

public static void main(String[] args) {

		Sub sub = new Sup();
		sub.a1();
		// 左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。
		if (sub instanceof Sub) {
			Sup sup = (Sup) sub;
		}
	}

多态的三种形式

public static void main(String[] args) {
		// 1 直接多态
		School s = new LiteSchool();
		// 2 形参和实参,方法参数列表为父类类型,调用方法传入子类对象
		m1(new LiteSchool());
		// 3 返回值多态,返回值类型是父类类型,但是返回子类对象
		School result = m2();
	}

接口:可以说是特殊的抽象类，由全局常量和公共的抽象方法所组成
抽象方法的集合，接口通常以interface来声明。
一个类通过继承接口的方式，从而来继承接口的抽象方法。
类描述对象的属性和方法。
类和接口之间,不再是继承关系，变成了实现关系，由extends换成了imp lements
接口名变量= new子实现类()也是会发生多态的
一个类只能继承一个类,但是可以实现N个接口，以逗号隔开,可以解决单继承功能变弱问题.
class类名imp lements接口1,接口2,接口3...接口和接口之间，是多继承，多个已逗号隔开
A interface接口名extends父接口名1,父接口名2..
一个类如果实现了一个接口，那么必须实现接口中所有的抽象方法，否则该类需要加abstract修饰
一个抽象类,实现一个接口,可以实现0~N个抽象方法

public class JieKou_ {
	public static void main(String[] args) {

	}
}

// 默认公共抽象
interface A {
	// 静态常量：public static int i= 1;
	int a = 1;

	// 公共、抽象的方法 public abstract void m（）；
	void m();

	static void m2() {
		// 静态方法，可以拥有方法体
	}
}

interface C {
	// 静态常量：public static int i= 1;
	int a = 1;

	// 公共、抽象的方法 public abstract void m（）；
	void m();

	static void m2() {
		// 静态方法，可以拥有方法体
	}
}

interface B {
	// 静态常量：public static int i= 1;
	int a = 1;

	// 公共、抽象的方法 public abstract void m（）；
	void m();

	static void m2() {
		// 静态方法，可以拥有方法体
	}
}

// 使用接口，要实现接口中所有的方法
class D implements A, B, C {

	@Override
	public void m() {
		// TODO Auto-generated method stub

	}

}

抽象
       修饰符
       在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，
      如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
      抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
       abstract和final不能重复出现

public class Abstract {
	public static void main(String[] args) {

	}
}

// 抽象类:不难实例化对象，抽象类中可以没有抽象方法。
abstract class Animals {

	// 抽象方法：必须在抽象类中。没有方法体，不能实现
	public abstract void m();

}

class Dog {
	// 对方法的覆写，也叫做实现
	public void m() {
		System.out.print("狗杂");
	}
}

Object是所有类的祖类,是java中提供的根类
    一个类没有 显示继承另一个类的时候,默认继承object
    Object XX = new xxx() :是可以发生多态的

equals的覆写

用来比较两个对象是否相等，默认比较地址
 "=="比较当前值的大小

@Override
	public boolean equals(Object obj) {
		// 判断是不是同一个对象
		if (this == obj) {
			return true;
		}

		// 向下转型
		if (obj instanceof Student) {
			Student s2 = (Student) obj;
			if (this.id == s2.id) {
				return true;
			}

		}
		return false;
	}

finalize:垃圾回收时自动调用

垃圾：一个对象没有更多引用指向他时，视为垃圾。（创建了对象，但是找不到）

public class Object_02_Finalize {
	public static void main(String[] args) {
		Person p = new Person();
		p = null;
		// 建议回收
		System.gc();
	}
}

class Person {
	// 垃圾回收
	@Override
	public void finalize() {
		System.out.print(this + "回收");
	}
}

tostring :代表了当前对象的字符串表示形式
当我们打印一个引用类型变量的时候会自动调用该对象的   toString  方法
而0b,ject中默认的toString方法是打印该对象的内存地址
 

//toString 覆写
@Override
	public String toString() {
		return this.name + ":" + this.id;
	}