java----面对对象

对象被创建的步骤

1.分配对象空间，并将对象成员变量初始化为0或空

2.执行属性值的显式初始化

3.执行构造方法（此时的对象已经被创建，我们可以在这一步对对象进行进一步的初始化工作）

4.返回对象的地址给相关的变量

面对对象：

public class Demo {
	public static void main(String[] args){
		Horse h = null;
		h = new Horse();
//		h.name = "dd";
		h.eat();
		h = null; //释放对象
	}
}

class Horse{
	String name;
	public void eat(){
		System.out.println(name);
	}

}

　　

封装性：

public class Demo {
	public static void main(String[] args){
		Horse h1 = new Horse();
//		h1.name = "小明";//由于 name设置了私有字段，此时在给对象赋值，会报错；
		h1.setName("小明");
		System.out.println(h1.getName());
}
}
class Horse{
	//属性的封装
	private String name;
	private int age;     //成员变量，在类中定义，在堆内存，对象清空，则成员变量清空，有默认初始值，像String引用变量初始值为null，int的初始值为0；
	public void setName(String name){ //参数也是局部变量
		int a = 111; //局部变量；在方法中定义，在栈内存，方法调用完毕，就清空，没有初始值，必须定义，赋值后，才能调用。
		this.name = name;
	}
	public String getName(){
//		return name;
		return this.name;  // 可以使用this调用其他方法和属性，this可以省略，this前面可以加上类名  Horse.this.name();
	}
}

　　

构造方法和构造方法的重载：

类似python中的__init__(self){}

public class Demo {
	public static void main(String[] args){
		Horse h = new Horse();
		Horse h2 = new Horse(1);
	}
}
class Horse{
	public Horse(){ //方法名称和类名相同，没有返回值
		System.out.println("我是构造方法");
	}
	public Horse(int a){
		System.out.println("a="+a);
	}
}

构造方法之间的调用，用this()

public class Demo {
	public static void main(String[] args){
		Horse h2 = new Horse(1);
	}
}
class Horse{
　　　　 public Horse(){  //默认构造方法，可以保留
　　　　　　
　　　　}
	public Horse(String b){ //方法名称和类名相同，没有返回值
		System.out.println(b);
	}
	public Horse(int a){
		this("11");  //调用另一个构造方法，注意，这条语句，只能放在最前面，否则报错；，限制了，不能调用多个；
　　　　　　　　　 this("22");  //报错，只能调用一个
		System.out.println("a="+a);
	}
}

对象之间的关联：

public class Demo {
    public static void main(String[] args){
    	Hero hero1 = new Hero("刘备");
    	Weapon weapon1 = new Weapon("双股剑");

    	hero1.setWeapon(weapon1);//将对象传递给一个对象，实现对象之间的关联

    	System.out.println(hero1.getWeapon().getName());

}
}
class Hero{
    //属性的封装
	private String name;
	private Weapon weapon;

	public Hero(String name){
		this.name = name;
	}

    public void setWeapon(Weapon weapon){
    	this.weapon = weapon;
    }
    public Weapon getWeapon(){
    	return this.weapon;
    }
}
class Weapon{
	private Hero hero;
	private String name;
	public Weapon(String name){
		this.name = name;
	}
	public void setHero(Hero hero){
		this.hero = hero;
	}
	public String getName(){
		return this.name;
	}
}

　　

继承：

方法的重载：发生在同一个类中，函数名相同，参数列表不相同，与返回值返回值(类型)无关；

方法的重写：发生在继承的关系中，函数名相同，参数列表相同，返回值(类型)需要相同。子类的访问修饰符需要大于或者等于父类的访问修饰符，子类的异常声明要小于或等于父类的异常声明，如果方法被private 、static修饰,那么方法不能被继承/重写。 final修饰，只能继承，不能重写

public class Demo {
    public static void main(String[] args){
    	Dog dog = new Dog();    //子类创建对象时 ，也会 自动 调用父类的默认的构造方法
    	System.out.println(dog.name);
    	dog.print();
    }
}

class Animal{
	protected String name = "动物";
	public Animal(){
		System.out.println("我是Animil 默认构造方法");
	}
	public Animal(String name){
		System.out.print("我是Animial  传参构造方法");
	}
	public void print(){
		System.out.println("Animal");
	}
}
class Dog extends Animal{   //继承的写法
	public Dog(){
		super("传值");       //如果有super，就会继承super所指的构造方法，具体执行那一个，看传参的列表
//		super();            //如果没有传值，就会执行父类的默认的构造方法，前提父类必须保留默认的构造方法；
							//注意1：默认情况下，会自动添加super()，如果自己写了super，就会覆盖默认的
							//注意2：super(),只能方法最开始的位置
	}
	public void print(){
		super.print();     //继承父类的方法;
		System.out.println("Dog");
	}
}

抽象类：

1、抽象类可以没有抽象方法，有抽象方法的一定是抽象类

2、非抽象类继承抽象类必须实现所有的抽象方法

3、抽象类可以继承抽象类，可以不实现父类的抽象方法

4、抽象类可以有方法实现和属性

5、抽象类不能被实例化

6、抽象类不能声明final

7、抽象类可以有构造方法

public class Demo {
    public static void main(String[] args){
    	Dog dog = new Dog();
    }
}

abstract class Animal{    //声明该类是一个抽象类，只能继承，不能实例化
	{
		System.out.println("可以有构造方法");
	}
	public abstract void eat();  //可以没有抽象方法  ,如果有了抽象方法，该类必须是抽象类,并且该抽象方法必须子类实现;
	public void run(){           //普通的方法可以不用被实现
		System.out.print("我可以跑");
	}
}

class Dog extends Animal{
	public void eat(){

	}
}

　　

接口：

1、抽象类实现接口，可以不实现接口的方法，非抽象类，必须实现接口的所有的方法；

2、接口的方法没有声明访问修饰符，默认为public

3、接口不能有构造方法，接口不能被实例化

4、接口之间的继承用extends ，定义接口用interface ,类实现接口用implements

5、接口只能定义常量，抽象方法，(jdk1.8之后有默认的实现方法，和静态方法)

6、final不可以修饰接口

public class Demo {
    public static void main(String[] args){
    	Person person = new Person();
    	person.print();  //默认的方法实现;
    }
}

interface IEat{
//	public abstract void eat();
	void eat();  //简写，定义抽象方法

//	public final static int NUM = 10;
	int NUM = 10; //简写,定义常量

	public default void print(){
		System.out.println("默认方法实现");  //jdk1.8之后有 默认方法实现（加上default），不能有其他的方法实现
	}
}
interface ISleep{
	void sleep();
}
interface IRun extends IEat,ISleep{   //接口可以有多继承
	void run();
}

class Person implements IRun,ISleep{  //接口的实现，类可以继承多个接口(不是接口的继承)
	public void sleep(){}             //必须实现接口的所有的方法
	public void run(){}
	public void eat(){}

}

　　

多态：　　

public class Demo {
    public static void main(String[] args){
    	Chick smailchick = new SmailChick();  //用父类的引用指向子类对象，(用大的类型接受小的类型，向上转型，自动转换)
    	eat(smailchick);

    	SmailChick smailchick2 = new SmailChick();
    	eat(smailchick2);

    	Chick bigchick = new BigChick();
    	eat(bigchick);
    }
    public static void eat(Chick c){  //多态性，Chick可以接受比他小的或者等于他的类型，(例如int可以接受short类型)
    	c.eat();
//    	c.song();  //直接写会报错，原因Chick中没有song方法，在运行的时候，c才是所new的对象，在编译的时候c还是chick

    	if(c instanceof BigChick){              //在转换之前做类型的判断
//    		BigChick bigchick = (BigChick)(c);  //若果父类中没有定义song()方法，就需要   强制转换  将Chick转变成BigChick
//    		bigchick.song();
    		((BigChick)c).song();               //简写
    	}
    }
}

abstract class Chick{
	public abstract void eat();
}
class SmailChick extends Chick{
	public SmailChick(){
		super();
	}//默认自动添加
	public void eat(){
		System.out.println("我是小鸡，我爱吃米");
	}
}

class BigChick extends Chick{
	public void eat(){
		System.out.println("我是大鸡，我爱吃虫");
	}
	public void song(){
		System.out.println("我是大鸡，我会唱歌");
	}
}

this的本质

指明当前的对象，不能放到static静态方法中

class Test{
    int a;
    public Test(int a){
        //给成员变量进行赋值
        this.a = a;
    }
    public Test(){
        //调用另一个构造方法,只能放在代码的第一行(所以只能有一个)
        this(1);
    }
}

java中的new到底为我们做了什么？

　　参考https://www.cnblogs.com/KingIceMou/p/7245446.html

String 中的hashcode()和equals()?

hashcode和equals都是为了对比两个对象是否相等一致，那么为什么会有两个呢？

　　hashcode()的判断是比较高效的，如果hashcode不一样那么这两个对象一定不相等。但是hashcode相等不能代表这两个对象一定相等，需要equals进行复杂的逻辑判断最终确定是否相等。所有我们在equals判断之前先判断hashcode是否相等可以一定程度提高效率，之后hashcode为了false，就可以不需要在判断equals了。

　　hashcode目的只是让一个对象只存在唯一的hashcode值，但是一个hashcode值可能会被多个对象共享。所以只要两个对象的hashcode值不相等，那他们对象肯定是不相等的。

　　这种大量的并且快速的对象对比一般使用的hash容器中，比如hashset,hashmap,hashtable等等，比如hashset里要求对象不能重复，则他内部必然要对添加进去的每个对象进行对比，而他的对比规则就是像上面说的那样，先hashCode()，如果hashCode()相同，再用equal()验证，如果hashCode()都不同，则肯定不同，这样对比的效率就很高了。

我们再来看看String中的hashcode和equals？

　　String重写了objdect中的hashcode()和equals()方法，所以这两个方法都可以用来判断字符串是否相等。只需要使用任意一个就可以判断？

　　new Object().equals（objdect）所有的类中默认的equals方法都是和"=="一样的效果，判断内存地址是否一样，只是String重写了equals。

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("11");
        System.out.println(stringBuilder.hashCode());
        stringBuilder.append("1");
        //比较的是内存地址
        System.out.println(stringBuilder.hashCode());

        String a = "a";
        String b = "a";
        System.out.println(a.hashCode()+"=="+b.hashCode()
);

　　

补充

访问修饰符