Java面向对象基础

Java面向对象学习 ------------ Day3

一、类与对象

1. 类的创建

   • 类是一个模板，是抽象的，需要实例化
   • 类实例化后会返回一个自己的对象

   //举例学生类的创建
   public class Student(){
   	//属性：字段 存在默认初始化
       String name;
       int age;
       //方法
       public void study(){
           ...
           方法体
   	}
   }

2. 对象的创建

   必须使用new关键字创造对象

   //对象student 
   Student stuent = new Student();
   //student就是Student类的具体实例！

3. 构造器

   特征：和类名相同；没有返回值；

   作用：new的本质是在调用构造方法；初始化对象的值（类似c++里的构造函数）

   注意点：定义了有参构造后没有了默认的无参构造，若要使用无参构造需要显式定义一个（AIt + insert）

   //Student无参构造
   public Student(){
   }

二、封装

1. 定义

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

   封装是数据的隐藏，通常应禁止直接访问一个对象中数据的直接表示，而应通过操作接口来访问。

2. 属性私有

   类中的属性设置为私有private，需通过getter/setter（AIt + insert）来获取与设置，在类外部无法直接访问。

三、继承

1. 定义

   1. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

   2. 继承是类和类之间的一种关系，两个类，一个为父类（基类）一个为子类（派生类）。

   3. 子类继承父类，就会拥有父类的全部方法；用关键字extends来表示。

2. this / super

   • this ：本身调用者这个对象；没有继承也能使用
   • super ：父类对象的应用；只有在继承条件才能使用

   //父类
   public class Person {
       String name = "sang";
       public void test(){
           System.out.println(this.name);//结果为 sang
       }
   
   }
   //子类
   public class Student extends Person{
       private String name = "joker";
       public void print(){
           System.out.println(this.name);//结果为 joker
           System.out.println(super.name);//结果为 sang
       }
   }

3. 方法重写

   1. 要求
   • 方法名必须相同
   • 参数列表列表必须相同
   • 修饰符:范围可以扩大但不能缩小 :public>Protected>Default>private
   • 抛出的异常:范围，可以被缩小，但不能扩大;classNotFoundException -->Exception(大)
   2. 静态方法与非静态方法重写区别：
   • 静态方法其调用只和左边定义的数据类型有关，如 Student student = new Person()
   • 非静态方法则为方法重写
   3. 实例：

   //父类
   public class Person {
       public void test(){
           System.out.println("sang");
       }
   }
   //子类
   public class Student extends Person{
   	//方法重写（AIt + insert）
       public void test() {
           System.out.println("joker");
       }
   }
   //main
   public class Application {
       public static void main(String[] args) {
           Student student = new Student();
           Person person = new Student();
           person.test();//子类重写了父类的方法，执行子类的方法 joker
       }
   }

三、多态

1. 定义

   即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

   一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多(父类，有关系的类)。

2. 条件

   • 有继承关系
   • 子类重写父类方法
   • 父类引用指向子类对象

3. instanceof

   看 System.out.println(X instanceof Y); 能否编译通过，若能通过代表X类与Y类有关系，若返回true则存在包含关系，false则不存在包含关系。

4. 几种代码块

   public class Person{
   //2：赋初值~（第二）
   {
       System.out.println("匿名代码块");
   }
   //1：只执行一次~（最先执行）
   static{
   	System.out.println("静态代码块");
   }
   //3：（最后）
   public Person(){
       System.out.println("构造方法");
   }
   public static void main(string[]args){
       Person person1 new Person();
       System.out.println("==============");
       Person person2=new Person();
   }

四、抽象类

1. 目的与要求

   • 提供基础实现，约束子类行为
   • 其中可包含实例变量/静态变量/常量，具体方法 + 抽象方法（只有方法名字没有具体实现）
   • 不能new抽象类，抽象方法必须在抽象类中、

2. 典型结构

   //抽象类 abstract
   public abstract class Shape{
       private String color;  
        public Shape(String color) { 
           this.color = color;
       }
       public abstract double area(); //抽象方法，后续子类必须实现
       
   }

五、接口

1. 定义与要求

   • 定义行为契约，解耦实现
   • 仅允许有public static final 常量与抽象方法（jdk8及之后支持 default/static 方法）
   • 可多继承

2. 典型结构

   //接口 interface
   public interface Drawable {
       // 传统抽象方法
       void draw();  
   }
   //实现类
   public class Circle implements Drawable {
       @Override
       public void draw() {  // 必须重写冲突方法
           System.out.println("draw");// 显式指定接口
       }
   }