java学习 Day06 Markdown学习

面向对象

创建对象

 //学生类
 public class Student {
     
     String name;
     int age;
     
     
     public void study(){
         System.out.println(this.name+"在学习");
     }
 }
 ​

实例化

 //同一文件夹
 public class Application {
     public static void main(String[] args) {
         Student saving = new Student();//实例化 saving
         saving.name = "saving";
         
         System.out.println(saving.name);
     }
     //实例化类
 ​
 }
 ​

构造器

一个类即使什么都不写，也会存在一个构造器

 ​
 public calss Person{
     //无参数构造器
     
     
     String name;
     //实例化初始值
     //使用new关键字，本质是在调用构造器
 ​
     
     public Person(){
         this.name = "saving"
     }
 }

 //有参数构造：一旦定义了有参数构造，无参构造必须显示定义
 ​
 public calss Person{
     //无参数构造器
     
     
     String name;
     //实例化初始值
     //使用new关键字，本质是在调用构造器
 ​
     
     public Person(){}//必须显示着
     
     public Person(String name){
         this.name = name;
     }
 }

封装

实则是数据的隐藏

设计程序追求：高内聚，低耦合

属性私有 get/set

 private String name;//私有定义
 //在另一个类中不能调用私有属性

获取私有属性值的方法 get/set

 public String getName(){
     return this.name
 }
 ==============================
 saving.getName();//获取名字
 ​

demo application

 ​
 public class Application {
     public static void main(String[] args) {
         Students saving = new Students();
         saving.setName("saving");
         System.out.println(saving.getName());
         saving.setAge(999);
         System.out.println(saving.getAge());
     }
 ​
 }
 ​

demo Students

 ​
 ​
 public class Students {
     //名字
     private String name;
     //性别
     private int age;
     //睡觉（）
     //学习（）
     public String getName(){
         return this.name;
     }
     
     public void setName(String name){
         this.name = name;
     }
     
     public int getAge() {
         return age;
     }
     
     public void setAge(int age) {
         this.age = age;
     }
 }
 ​

方法重写

重写都是方法重写，和属性无关

父类的引用指向了子类

静态方法

//A类

public class A extends B{
	public static void test() {
		System.out.println("A");
	}
}

//B类
public class B {
	public static void test(){
		System.out.println("B");
	}
}

调用

public class Application {
	public static void main(String[] args) {
		
		//方法的调用只与定义的类型有关
		A a = new A();
		a.test();
		//父类的引用指向了子类
		B b = new A();
		b.test();
		
	}

}

输出：

A

B

//非静态才有重写

public class A extends B{
	@Override//注解   Override 重写
	public void test() {
		super.test();
	}
}

//B类
public class B {
	public void test(){
		System.out.println("B");
	}
}

调用

public class Application {
	public static void main(String[] args) {
		
		//方法的调用只与定义的类型有关
		A a = new A();
		a.test();
		//父类的引用指向了子类
		B b = new A();
		b.test();
		
	}

}

总结

1. 重写需要有继承关系，子类重写父类的方法！

2. 方法名必须相同

3. 参数列表必须相同

4. 修饰符：范围可以扩大： public>protected>Default>private

5. 抛出异常：范围，可以缩小，但不能扩大

重写的原因：

1. 父类的功能，子类不一定需要或者满足

   Alt + Insert：override

多态

public class Application {
	public static void main(String[] args) {
		
		//Student能调用的方法都是自身的或者继承父类的
		Student s1 = new Student();
		
		//Person父类可以指向子类，但不能调用子类独有的方法
		Person s2 = new Student();
		Object s3 = new Student();
		//对象能执行哪些方法主要看对象左边的，和右边的关系不大
		s1.run();
		s2.run();//重写了父类run
	}

}

//Student
public class Student extends Person {
	@Override
	public void run() {
		System.out.println("son");
	}
}

//Person
public class Person {

	public void run(){
		System.out.println("run");
	}
}

总结

1. 多态是方法的多态，属性灭有多态

2. 父类和子类，有联系 没联系强转会类型转换异常

3. 存在条件：有继承关系，方法需要重写

4. 父类的引用指向了子类对象

   Person s2 = new Student（）；

5. 不能重写

   static 方法属于类，不属于实例

   final常量

   private方法

instanceof

判断是否为该类型正不正确

public class Application {
	public static void main(String[] args) {
		
		//Object>Person>Student
		Object object = new Student();
		
		System.out.println(object instanceof Student);//ture
		System.out.println(object instanceof Person);//ture
        System.out.println(object instanceof String);//false编译报错
	}

}