Day5 JAVA复习

此篇结束后接我的收藏

九、面向对象

1.类和对象

1.1类

• 具有相同特征（属性，行为）的一类事物抽象

1.2对象

• 通过类实例化的一个实体

1.3面向对象编程，面向过程编程

• 互相包容，只不过某些部分单独拿出来说是面向对象（/面向过程）的

1.4构造方法

/**
 * 1.类体中包含成员变量（方法中可以定义局部变量）和成员方法
 * 1.类成员：成员变量和方法
 * 3.变量的分类：
 * 		成员变量：类体里定义的变量（有没有static修饰：分为类变量和实例变量（对象））
 * 		局部变量：方法中的变量
 * @author TEDU
 *
 */
public class Student {
	/**
	 * 1.什么是构造方法：方法名是类名，没有返回类型
	 * 2.来源：默认（没有定义）、自定义（自定义之后不存在默认的构造方法）
	 * 构造方法可以有无数个（重载）
	 * 默认构造方法的特点：public 无参
	 * 3.作用：和new一起申请内存，创建对象
	 * 4.使用构造方法:不能通过对象.构造方法的方式使用
	 * 5.定义多少个？通常有两个，一个无参的，一个全参的
	 */
	//void Student(){}
	 //Student(){}
	// public Student(){}
	public Student getStudent(){
		return new Student();
	 }
	//void Student(String name){
	//	System.out.println("student");
//	}
	String name;
	String no;
	static int a;
	
	public void study(String str){
		int i;//不能自动分配内存，想使用必须有值
		//System.out.println(i);局部变量使用之前必须先赋值
		System.out.println(str);
		System.out.println(a);
		System.out.println("学习");
	}
	public static void main(String[] args) {
		Student a=new Student();
		a.study("");
	}
}

1.5构造快

public class Demo {
	//构造块先于构造方法执行
	//构造方法初始化的相同内容可以放到构造块中
	{
		System.out.println("???");
	}
	public Demo(){
		System.out.println("demo");
	}
	{
		System.out.println("???");
	}
???
???
demo

}

1.6局部块

public void f(){
		//局部块,局部块中内容执行完后立即回收，方法中的内容方法结束后才会回收,提高内存使用率
		{
			int x=9;
			x+=2;
			System.out.println(x);
			
		}
		System.out.println("222");
	}

1.7this

表示指向当前类的对象
this.调用本类成员
this[实参列表]：必须是构造方法的第一条有效语句

2面向对象

2.1面向对象的三大特征

封装、继承、多态

2.2封装

为什么实现封装“为了隐藏数据的内部信息，保证成员变量的逻辑的正确性
实现封装的步骤：
1.变量的私有化
2.定义set、get方法”

public class Person {
	//封装1：限制age的访问范围
	//2.private 表示只限于本类使用
	private int age;
	//3.提供set、get方法让其他类进行访问
	public void setAge(int age) throws Exception{
		if(age>0&&age<130){
		this.age=age;
		}else{
			throw new Exception("错误！");
		}
	}
	public int getAge(){
		return age;
	}
	public void showInfo(){
		System.out.println(age);
	}
}

public class TestPerson {
	public static void main(String[] args) {
		Person p=new Person();
		try{
				p.setAge(-2);
		System.out.println(p.getAge());
		}catch(Exception e){
			//获取异常信息
			System.out.println(e.getMessage());
		}
	}
}

2.3继承

1.由已经存在的一个类，产生新类的过程（机制），叫继承
2.父类和子类：已经存在的类叫父类，产生的新类叫子类
3.extends表示继承关系
4.单一继承
5.满足一个关系
6.子类可以继承除了构造方法之外的所有成员，但是私有成员不能使用
7.object是顶级类，所有类默认继承object
8.什么时候定义子类：子类有自己的成员（变量或方法）

2.3.1super关键字

• super表示指向父类的对象
• super.成员
• super（实参列表）：必须为构造函数的第一条有效函数。
• super可用在成员方法中,不能用在静态方法中

2.3.2访问修饰符

private、default、protected、public

2.3.3方法的重写

• 继承
• 子类的方法：方法名相同,/方法的返回类型（基本数据类型，如果是引用类型，子类方法的返回类型可以是子类类型），参数列表相同访问修饰符>=父类，异常<=父类
• 子类的方法重写了父类的方法（方法覆盖）
• 为什么重写？父类的方法不能满足子类的需求，重写父类的方法
  私有方法是否可以被重写？私有方法子类不可以访问，不存在私有方法被重写
  

2.3.4继承关系中构造方法的调用

1.子类创建对象，调用父类无参的构造方法
2.如果父类没有无参的构造方法，那么使用super调用父类定义好的构造方法
//instanceof判断对象是否为某一种类型
if（父类 instanceof 子类）{
（子类）（父类）.方法
}

2.4多态（一种类型可以指向不同的对象）

Animal d=new Dog();
Animal b=new Bird();
同名方法体现：
1.方法重载：编译时绑定（编译时多态）
2.方法重写：（运行时多态）
Animal d=new Dog();
编译时会找父类的方法
运行时动态绑定到各自子类的方法

class Demo8 {
	int x=9;
}
 class Demo9 extends Demo8{
	 int x=90;
	 public void test(){
		 System.out.println("test");
	 }
 }
public class TestDemo8{
	 public static void main(String[] args) {
		 //哪个类声明，编译时就找哪个类的成员
		 //子类如果重写父类的方法，运行时动态绑定
		 //父类声明，子类创建动态创建
		Demo8 d=new Demo9();
		System.out.println(d.x);
	}
 }

静态方法是否可以重写？不可以，子类的静态方法被隐藏

class Demo8 {
		 int x=8;
		 public Demo8(){
			 System.out.println("Demo8");
		 }
		 public void test(){
			 System.out.println("Demo8test");
		 }
		 public static void f(){
			 System.out.println("demo8f");
		 }
	}
	 class Demo9 extends Demo8{ 
		 int x=9;
		 public Demo9(){
			 System.out.println("Demo9");
		 }
		 public void test(){
			 System.out.println("Demo9test");
		 }
		 public static void f(){
			 System.out.println("demo9f");
		 }
	 }
	public class TestDemo8{
		 public static void main(String[] args) {
			Demo8 d=new Demo9();//父类声明，子类创建动态创建,先执行声明的构造函数，再执行创建的构造函数
			System.out.println(d.x); //哪个类声明，编译时就找哪个类的成员
			d.test(); //子类如果重写父类的方法，运行时动态绑定
			d.f();//子类的静态方法被隐藏
		}
	 }