第四节 Java面向对象

面向对象思想

类与对象

类的定义

class Person{
    //实例变量

    //类变量

    //构造方法
        //空构造方法
        //有参构造方法

    //实例方法

    //类方法

}

对象的创建与构造方法

    //构造方法
    public Circle(){

    }
    //构造方法的重载
    public Circle(double radius){
        this.radius=radius;
    }      

        //通过对象调用实例变量
            //通过空构造方法创建对象
        Circle circle = new Circle();
            //通过有参构造方法创建对象
        Circle circle1 = new Circle(20);

类变量与实例变量

实例变量

   //实例变量
    /*
        实例变量在对象创建的时候创建，在对象销毁的时候销毁
        实例变量具有默认值，数字为0，布尔为false，引用类型为null
        实例变量常用private修饰，用getter和setter方法操作。
        实例变量只能由对象名访问
     */
    private double radius;//半径

类变量

    //类变量
    /*
        类变量也叫静态变量
        无论一个类有多少对象，类变量只有一份。
        静态变量在程序开始时就创建，在程序结束时才销毁，不随对象转移。
        类变量常用public修饰
        类变量和实例变量一样的使用，而且还可以在静态代码块中声明。
        如果public static final修饰，那么作为常量，名称使用大写。
        类变量可以由类名和对象名访问
     */
    public static final double PI=3.14;//圆周率
    public static double sRadius;

类方法与实例方法

实例方法

    //实例方法
    /*
        实例方法可以操作实例变量和类变量
        实例方法只能由对象名访问
     */
    public double area(){
        return this.radius*this.radius*PI;
    }

类方法

    //类方法
    /*
        类方法只能访问类变量
        类方法中不能出现this或者super
        类方法可以由类名或者对象名访问
     */
    public static double getCircle(){
        return sRadius*sRadius*PI;
    }

面向对象综合实例

/**
* Java面向对象——类
*/
class Circle{//类的定义
    //实例变量
    /*
        实例变量在对象创建的时候创建，在对象销毁的时候销毁
        实例变量具有默认值，数字为0，布尔为false，引用类型为null
        实例变量常用private修饰，用getter和setter方法操作。
        实例变量只能由对象名访问
     */
    private double radius;//半径

    //类变量
    /*
        类变量也叫静态变量
        无论一个类有多少对象，类变量只有一份。
        静态变量在程序开始时就创建，在程序结束时才销毁，不随对象转移。
        类变量常用public修饰
        类变量和实例变量一样的使用，而且还可以在静态代码块中声明。
        如果public static final修饰，那么作为常量，名称使用大写。
        类变量可以由类名和对象名访问
     */
    public static final double PI=3.14;//圆周率
    public static double sRadius;


    //构造方法
    public Circle(){

    }
    //构造方法的重载
    public Circle(double radius){
        this.radius=radius;
    }

    //实例方法
    /*
        实例方法可以操作实例变量和类变量
        实例方法只能由对象名访问
     */
    public double area(){
        return this.radius*this.radius*PI;
    }

    //类方法
    /*
        类方法只能访问类变量
        类方法中不能出现this或者super
        类方法可以由类名或者对象名访问
     */
    public static double getCircle(){
        return sRadius*sRadius*PI;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public static double getsRadius() {
        return sRadius;
    }

    public static void setsRadius(double sRadius) {
        Circle.sRadius = sRadius;
    }
}
public class 面向对象 {
    public static void main(String[] args) {
        //通过类名调用类变量
        System.out.println(Circle.PI);
        Circle.sRadius=10;
        //通过类名调用类方法
        System.out.println(Circle.getCircle());

        //通过对象调用实例变量
            //通过空构造方法创建对象
        Circle circle = new Circle();
            //通过有参构造方法创建对象
        Circle circle1 = new Circle(20);
        circle.setRadius(1);
        circle.setsRadius(2); //对象操作类变量
        System.out.println(circle.getRadius());
        System.out.println(circle.sRadius);//对象获取类变量
        System.out.println(Circle.sRadius); //类名操作类变量

        System.out.println(circle.getCircle());
        System.out.println(Circle.getCircle());
        System.out.println(circle.area());
    }
}

封装

封装的主要功能在于我们能修改自己的实现代码，但是不需要修改调用程序部分。

也就是说，修改类中的实现，而不需要修改Main函数。

封装的优点：
1. 良好的封装可以减少耦合
2. 类内部的结构可以自由修改
3. 可以对成员变量进行更精确的控制
4. 隐藏信息，实现细节

Java实现封装的步骤
1. 限制对属性的访问
2. 对属性提供对外的公共方法
3. 关键词private,protected,public,default其中default是隐藏的

public class Person{
    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;
    }
}

继承

继承的格式

class Animal{
    //code
}
class Dog extends Aniaml{
    //code
}

继承的优点
1. 实现代码的可重用
2. 增加了代码的可维护性

继承的特性
1. 子类拥有符类非private的属性和方法
2. 子类可以拥有自己的属性和方法，即拥有继承权，同时也拥有自己的个性。
3. 子类可以对父类的方法进行重写，即同一件事，孩子可以青出于蓝而胜于蓝。
4. java是单继承的。
5. 继承的缺点就是增加了代码的耦合性。耦合性就是代码之间的联系。

super和this关键字
- super，引用当前对象的父类
- this，引用本对象

final关键字
- 修饰变量则表示常量 final double PI=3.14;
- 修饰类，表示该类不能被继承 final class Person{}
- 修饰方法，表示该方法不能被子类重写 final int getMax(int a,int b){return a>b?a:b;}

构造方法
1. 子类不能继承父类的构造方法
2. 父类的构造方法必须在子类的构造方法中优先调用。
3. 如果是父类是有参构造方法，那么需要通过super(参数)显式调用。
4. 如果父类有无参构造方法，那么java会自动调用super()构造方法

多态

同一个事件发生在不同对象上会产生不同的结果，这就是多态

扫描二维码关注公众号，回复： 438489 查看本文章

多态的优点

消除类型之间的耦合关系
可替换，可扩充，灵活，接口，简化

出现多态的3个必要条件
1. 继承
2. 重写
3. 父类引用指向子类引用

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法,参数中是Animal cat = new Cat();
      show(new Dog());  // 以 Dog 对象调用 show 方法,参数中是Animal dog = new Dog();

      Animal a = new Cat();  // 向上转型 ,父类引用指向子类 
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  

    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}

abstract class Animal {  
    abstract void eat();  
}  

class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

多态的实现方式
- 方式一、重写
- 方式二、接口
- 方式三、抽象类和抽象方法

抽象类与接口

抽象类

抽象类的特点

抽象类用abstract修饰
抽象类必须继承使用，必能实例化对象
抽象类可以包含抽象方法和非抽象方法。
有抽象方法的必须声明为抽象类。
子类必须重写父类的所有抽象方法，如果全部重写，那么子类也必须是抽象类
构造方法和类方法不能声明为抽象方法

abstract class Animal{
    private String name;
    private int age;

    public abstract void sleep();
    public abstract void eat();
    public void drink(){
        System.out.println(this.name+"正在喝水...");
    }


    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;
    }
}

class Cat extends Animal{
    public void sleep(){
        System.out.println(this.getName()+"正在睡觉");
    }
    public void eat(){
        System.out.println(this.getName()+"正在吃饭");
    }
}

接口

接口的特点

    * 接口不能实例化对象
    * 接口没有构造方法
    * 接口所有方法都是抽象方法
        public abstract void print();
    * 接口不能包含成员变量，只包括全局常量
        public static final MSG="hello";
    * 接口需要被类实现。
    * 接口支持多实现

接口实例

interface Usb{
    public static final length=30;
    public static final weight=10;
}
//接口的继承
interface DataUsb extends Usb{

    public abstract void dataStream();//数据传输
}
interface ChongDianUsb extends Usb{

    public abstract void chongDian();//充电
}

class Computer implements DataUsb{
    public  void dataStream(){
        //code
    }   
}
//接口多实现
class Phone implements DataUsb,ChongDianUsb{
    public  void chongDian(){
        //code
    }
}