JAVA_面向对象_DAY03

---

一、Debug

看代码执行流程的工具

操作：F5 进方法 F6 执行下一行 F8 到下一 个断点

二、面向对象特点之 —封装

1.属性的封装

原来用public修饰的属性 现在用private关键字修饰
访问修饰符 public 公共的 在任何地方都可以访问
private 私有的 只能在本类中访问。
相当于将类中的属性进行私有化 ，但是当想给外界提供访问的时候，需要提供特殊的访问途径， 主要通过get和set方法进行访问

代码如下（示例）：

private String name ;
public void getname(String name){
 this.name = name;
}
public String setname(){
return name;
} 

三、面向对象特点之 —继承

描述对象关系的时候存在一种继承关系

管继承的类叫子类 被继承的类叫父类

此特点遵循：单继承关系

1.子类通过extends继承父类

一个子类只能有一个父类 一个父类可以有多个子类

父类 相对子类讲很抽象
子类 相对父类讲更具体

2.属性和方法的访问

子类可以使用父类的属性和方法 ，父类不能够访问子类独有的属性和方法

3.创建子类对象时

先调用父类的构造方法，再调用子类的构造方法

4.小测试，用于判断执行的先后顺序

代码1：

package com.openlab.pojo;

public class Dog extends Animal {
	
	private static Dog d = new Dog("大黄",5);
	
	public String eyescolor;
	//  123 - Animal -Dog
	{
		System.out.println("000");
	}
	//静态代码块
	static{
		System.out.println("123");
	}
	
	public Dog(String name,int legs) {
		super(name, legs);
		System.out.println("This is  A DOG！！！");
	}
	public void eat(){
		System.out.println("干饭 ");
	}

}

代码2：

package com.openlab.pojo;

public class Animal {
	
	public String name;
	public int legs;
	
	{
		System.out.println("xxx");
	}
	static{
		System.out.println("456");
	}
	
	public Animal(String name,int legs) {
		System.out.println("This is  an  Animal！！！");
	}
	
	
	//  动物开心了的表达方式
	public void enjoy(){
		
		System.out.println("叫两声");
	}

}

代码3：

package com.openlab.pojo;

public class Test {
	
	public static void main(String[] args) {
		Dog d = new Dog("大黄",5);
		d.enjoy();
		
//		Animal  a = new Animal();
		
	
	}

}

注意：看到一个类要先看这个类的继承关系，尤其注意static
结果，输出的执行顺序如下：

456//父类静态代码块
xxx//父类代码块
This is an Animal!!!//父类构造方法
000//子类代码块
This is a DOG!!!//子类构造方法
123子类静态代码块
xxx//父类代码块
This is an Animal!!!//父类构造方法
000//子类代码块
This is a DOG!!!//子类构造方法
叫两声//子类方法

1.父类的静态代码块 只执行一次 并且在类加载的时候执行
2.子类的静态代码块
3.父类的代码块
4.父类的构造方法
5.子类的代码块
6.子类的构造方法

总结：
在一个类中，不论是静态的代码还是静态的变量都是按照在这个类中的代码先后顺序执行的。

四、Super关键字

超类基类的引用
不可以当返回值使用

五、继承类中引用数据类型的转化

1.遵循与基本数据类型中的数值型一样的规则：

引用数据类型的转换
小的类型转大的类型叫向上转型 自动转换
大的类型转小的类型叫向下转型 强制转换

2.instanceof 关键字

用于判断引用数据的类型
代码如下（判断aa是否为Dog的引用数据类型）：

Animal aa = new Dog("大hong",6);
		Animal aaa = new Cat("Bosi",4);
		//对象   type ---类型
		if (!(aa instanceof Dog)) 
			
			System.out.println(false);
		else{
			Dog ddd = (Dog) aa;
		}

3.classcastException 类型转换异常

五、Override重写

定义：
发生在两个类中 方法名相同 返回类型相同 参数列表相同 方法体不同
注意：子类重写父类的方法是 访问修饰符不能比父类更严格。
重写是多态的表现形式之一

六、面向对象特点之 —多态

对象的多种形态
多态的表现形式之一 父类引用指向子类对象
注意：1 父类引用访问不了子类独有的属性和方法
2.父类引用调用的重写的方法 会调用相应子类的重写的方法。

public static void main(String[] args) {
        People p=new Stu();
        //这里是直接调用子类重写中的内容（多态中唯一可以直接引用子类的内容）
        p.eat();
        //父类只有强制转换，才能调用子类中的特有的方法
        Stu s=(Stu)p;
        s.study();
        //((Stu) p).study();
    }
}
class People{
    public void eat(){
        System.out.println("父类吃");
    }
}
class Stu extends People{
    @Override
    public void eat(){
        System.out.println("子类吃");
    }
    public void study(){
        System.out.println("子类学习");
    }
}

七、static关键字

习题，口算出的count1，count2的值：

package com.openlab.pojo;

public class StaticTest {
	
	private static StaticTest st = new StaticTest();
	
	private static int count1;
	private static int count2 = 0;
	
	public StaticTest() {
		count1++;
		count2++;
	}
	public static StaticTest getInstance(){
		return st;
	}
	public static void main(String[] args) {
		
		StaticTest st = StaticTest.getInstance();
		System.out.println(StaticTest.count1);
		System.out.println(StaticTest.count2);
	}

}

总结：
1.被static关键字所修饰的属性和方法 被整个程序共享，通过类名直接调用
2.静态方法中不能访问非静态变量和方法
3.在非静态方法中不能声明静态的局部变量
4.被static修饰的属性 优先被加载 优先于主方法
5.静态代码块只执行一次 优先于代码块和构造方法
6.静态代码块和静态变量同时存在时 按照先后顺序执行

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。