javaSE09基础-面向对象三大特征

面向对象特征

封装

封装概念:

• 封装,将类的某些信息隐藏在类内部,不允许外部访问,而且时通过该类提供的方法来实现对隐藏信息的操作和访问

优点:

1. 隐藏类的实现细节
2. 类内部的结构可以自由的修改
3. 可以对成员精确的控制
4. 只能通过规定方法访问
5. 良好的封装能够减少耦合

具体表现

• 属性使用private权限
• 方法使用public权限

public class Person {
    private String name;
    private int age;
}

将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏

其构造方法，及Setter，Gestter方法.即每个值属性提供对外的公共方法访问,也就是创建一堆赋值的方法,用于访问私有属性的访问,例如:

public class EncapTest{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

this 关键字是为了解决实例变量（private String name）和局部变（setName(String name)中的name变量）之间发生的同名的冲突。

测试:

public class RunEncap{
   public static void main(String args[]){
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ 
                             " Age : "+ encap.getAge());
    }
}

this关键字

this关键字代表自身类的对象

• 使用this关键字引用成员变量

• 使用this关键字引用成员方法

  注意:this关键字必须放在非静态方法里面

使用“this.成员变量名”这样的格式来引用成员变量名，,常常硬来区分同名的成员变量呵和局部变量

继承

继承是面向对象程序设计思想,是实现代码可重用的根基,是提高代码可扩展性的主要途径。

• 继承是从已有的类中派生出新的类,新类能吸收已有类的属性和行为，并能扩展新的能力
  • Java中使用extends关键字来表示继承关系
  • java不支持多继承,一个子类只有一个父类
  • 继承后子类可以调用父类的所有非私有属性和非私有方法

使用继承

1. 符合is-a关系的设计,使用继承

2. 将子类共有的属性和行为放到父类中

   例如: 猫是动物, (子类)猫类的(父类)就是动物类

   继承是代码重用的一种方式

继承形式

[访问权限修饰符][修饰符]  子类名  extends  父类名{子类体}

父类(动物类)

public class Animal {
    public void eat() {
        System.out.println("动物吃");
    }
}

子类(猫类)

public class Cat extends Animal {
    public void play() {
        System.out.println("猫在玩耍");
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.play();//子类属性
        cat.eat();//父类属性
    }
}

专业术语

cat类是 Animal类的子类, Animal类是cat类的父类
cat类是 Animal类的派生类, Animal类是cat类的基类

继承传递性

• 继承后子类可以调用父类的所有非私有属性和非私有方法,并别可以多层传递,C类从B类继承,B类又从A类继承那么C类就具有B类和A类的所有非私有属性和非私有方法
• 当一个类没有继承任何一个类时,jvm会默认让继承Object类…Object是java为所有类提供的基类

super关键字

super关键字代表父类的引用,在程序中主要途径

• 在子类构造中调用父类的构造方法,super语句只能出现子类构造方法体的第一行
• 用"super.成员变量名"用来引用父类成员变量
• 用"super.方法名(参数列表)"的方式访问父类的方法.
• 与this的区别,this通常指代当前对象,super通常指代父类.

方法的重写

重写overRide 重载overload

子类方法根据父类中继承的方法进行重写

方法重写规则:

• 方法名相同,参数相同

• 返回值类型相同

• 访问权限相同

  -即于父类方法结构完全相同

  注意:构造方法不能重写

应用场景:当此父类的方法不能满足子类需求时,可以对方法进行重写(overRide)

package com.nie.day5.demo01;

public class Animal1 {
    private String a;
    private String eat;

    public Animal1() {
        super();
        System.out.println("Animal无参构造");
    }

    public Animal1(String a) {
        this.a = a;
        System.out.println("Animal有参构造");
    }

    public void eat() {
        System.out.println("动物吃");
    }

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }

    public String getEat() {
        return eat;
    }

    public void setEat(String eat) {
        this.eat = eat;
    }
}

package com.nie.day5.demo01;
import com.nie.day4.demo1.demo02.Animal;
public class dog extends Animal1 {

    /**
     * 子类构造方法,先调用父类的构造方法,默认情况下调用父类的无参构造方法
     * super 调用父类任意一个构造方法
     */
    public dog() {
        super();	//- 用"super.成员变量名"用来引用父类成员变量
					//- 用"super.方法名(参数列表)"的方式访问父类的方法.
        //super("d");//super语句只能出现子类构造方法体的第一行
        System.out.println("dog无参构造");
    }
      /**
     * 重写override   重载 overload
     * 方法名,参数列表相同
     * 返回值类型相同
     * 访问权限相同,   即父类的方法结构完全相同
     *  注意::   构造方法不能重写
     *
     *  场景: 父类的方法不能满足子类的时,需要对方法进行重写
     *
     *
     */
    @Override//表示此方法有父类重写而来
    public void eat(){
        System.out.println("狗吃");
        super.eat();
    }
    
}

测试

public class Test {
 
    public static void main(String[] args) {
        dog a = new dog();
        a.eat();
    }
}

Animal有参构造
dog无参构造
狗吃
动物吃

类之间关系–关联,依赖

关联

has-a

• 对象与对象之间的连接,.在Java中,关联关系的代码表现形式为一个类做为另外一个类的属性类型存在…类与类之间的一种最常用的关系。
• 即“有”的关系：”has-a”。

关联关系为:关联关系的多重性

1. 单向关联,自关联 一对一关联：一个学生，只能在一个班级里学习。
2. 双向关联:可以调用对对方的公共属性和方法，例如知道对方的存在供货商和顾客

双向关联

publc class Customer{
	//供货商对象数组作为顾客的属性成员
	private Supplier [] supplier;
}
public class Supplier {
	public Customer [] customer;
}

单向关联

publc class Customer{
	private Address address;
}
public class Address {

}

自关联

public class Customer{
private Customer customer;
}

依赖

use a 的关系为依赖关系

• 依赖关系(使用关系), 指一个类A使用到了另一个类B

• 依赖关系特性

  这种关系是具有偶然性的,临时性的,非常弱的,但是类B的变化会影响到类A

课表与课程之间:

class CourseTable{
	public void addCourse(Course c){
		c.show();
		System.out.println("新增课程");
	}	
	pubilc void deCourse(Course c){
		c.show();
		System.out.println("删除课程");
	}
}
class Course{
	System.out.println("课程为：");
}

多态

同一事物,在不同时刻表现不同的状态

多态存在的必要的三个条件:

• 要有继承(前提条件)
• 要有重写(前提条件)
• 父类引用指向子类对象

1. 当编译类型是父类,运行类型是子类时,被称为父类引用指向子类对象
2. 多态环境下对成员方法的调用 编译看左边，运行看右边。
3. 多态环境下对静态成员方法的调用 简单的说：编译和运行都看左边。
4. 多态环境下对成员变量的调用 编译和运行都看等号左边。注意:变量不出存在被子类覆写说法,只存在覆盖

方法的形参是父类类型,而传递的似乎实际参数可以是任意子类的对象

方法参数多态性的好处:提高代码的扩展性

父类(动物类)

package com.nie.day5.demo04;

/**
 * 多态
 * 同一种食物,在不同时刻表现不同的状态
 *
 * 多态存在的三个必须的条件
 * --要有继承
 * --要有重写
 * --父类指向子类对象
 */
public class Animal {

    int num=10;
    public  void eat() {
        System.out.println("动物吃");
    }
    static void show(){
        System.out.println("Animal");
    }

    public  void fly(){
        System.out.println("动物飞了");
    }
}

子类(猫)

package com.nie.day5.demo04;

public class Cat extends Animal {
    int num = 5;

    public void eat() {
        System.out.println("cat 吃");
    }

    static void show() {
        System.out.println("静态成员方法");
    }
    void  look(){
        System.out.println("看家");
    }
}

子类(狗)

package com.nie.day5.demo04;

/**
 * * --要有继承
 *  * --要有重写
 */
public class Dog  extends  Animal{
    public  void eat() {
        System.out.println("小狗一号  吃");
    }

}

子类(狗1)

package com.nie.day5.demo04;

public class Dog1 extends Animal {
    public   void eat() {
        System.out.println("小狗二号  吃");
    }
}

测试

package com.nie.day5.demo04;

public class Test {
    public static void main(String[] args) {
        //父类指向子类对象
        //父类     子类
        Animal a = new Cat();
        /**
         * 多态环境下对成员方法的调用
         * **编译看左边，运行看右边。**
         */
        a.eat();
        /**
         * 多态环境下对静态成员方法的调用
         * **简单的说：编译和运行都看左边。**
         */
        a.show();
        /**
         * a.num    编译和运行都看等号左边
         * 注意:变量不存在被子类覆盖写这一说法,只有方法存在覆盖
         * 调用的是父类的成员变量
         */

        System.out.println(a.num);
        Animal b = new Dog();
        b.eat();
        Animal c = new Dog1();
        c.eat();
        Test t = new Test();
        t.method(a);
    }
    //方法的形参是父类类型,而传递的是实际参数可以是任意子类的对象
    //提高方法参数多态性的好处：提高代码的扩展性
    public void method(Animal animal) {

        animal.eat();
    }

}

向上转型,向下转型

父类引用指向子类对象

• 向上转型的作用是：提高程序的扩展性。
• 向下转型的作用是:为了使用子类中特有的方法

public class Animal {
    int num=10;
   void eat() {
        System.out.println("动物吃");
    }

}

public class Cat  extends Animal{
    int num = 5;
   void  look(){
       System.out.println("看家");
   }
}

package com.nie.day5.demo05;

public class Test {//向下转型

    public static void main(String[] args) {

        Animal a = new Cat();//向上转型
        //多态的问题:父类类型不能访问子类特有的方法
        //解决办法: 向下转型
        String s = "ads";
        Object obj = s;
        //   大类型 instanceof 小类型  判断检测大类型中是否包含的是具体的小类型
        if (obj instanceof Cat) {
            Cat m = (Cat) a;//向下转型
            m.look();

        } else {
            System.out.println("不是");
        }
    }
}

---

final关键字

• final用于声明属性,方法和类
• 属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期不能修改
• 方法:子类不能被覆盖
• 类:不能被定义为抽象类或者接口,不可被继承.

final属性赋值:

–在声明时同时赋值,往往与static一起使用

final static int Num = 10;

package com.nie.day5.demo06;

public class Filal {
    //用于声明方法和类
    //final修饰常量,常量值不能变,利用static 修饰 节省空间
    final static int Num = 10;
    final int a = 100;


    public final void eat() {
        System.out.println("你好");
    }

    //定义就必须直接赋值或者在构造方法中进行中进行赋值,后期不能修改
    public void num(int a) {
//       this.a=1000;
        System.out.println(a);
    }


    //在方法参数前加final关键字,防止数据在方法题中被修改.
    public void num1(final int b) {
//        b=11;
    }
}

抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类

抽象类除了不能实例化对象之外,类的其他功能依然存在,名成变量,成员方法和构造方法的访问方式和普通类一样.

用abstract修饰的类就是抽象类,如果某个类中包含抽象方法,那么这个类就必须定义抽象类.

抽象方法:

• 抽象方法时一种特殊的方法:他只有声明,而没有具体的实现
• 抽象方法必须用abstract关键字进行修饰

抽象类可以有成员属性和非抽象方法

抽象类不能被实例化,但可以有构造函数.因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象

抽象类不能创建对象:抽象类只能做基类,表示一种继承关系.

构造方法和静态方法不可以用abstract

[访问权限] abstract class 类名 {
		成员列表
	}

public abstract class Shapes {
	public abstract void draw();
}

public abstract class Shapes {
	public void draw(){
         //具体代码
       }
}

抽象类,抽象方法.