java面向对象

java面向对象的三大特性：封装、继承、多态

类和对象的关系：

类是对象的抽象描述，类名并包括属性和方法两个主要部分

一、封装

例：

package Zsh.SuiSui03;

class FengZhuangDemoss{
public static void main(String[] args){
    Parson p = new Parson();
    p.setAge(-10);
    System.out.println(p.age);

    p.setAge(-10);
    System.out.println(p.age);
    p.setName("张三");
    System.out.println(p.getName());

    // Student student = new Student();
    // p.say(Student);//匿名对象
    // p.say(Student);//与上一行相同


    p.say(new Student());//匿名对象，只能用一次，如果需要再次使用要再次new一个对象
    p.say(new Student());
    }
}

class Parson {
    int age;
    private String name;//封装

    public void setAge (int a){
        if(a<0){//传入的参数不符合常理
            a = 20;
        }else{
            age = a;
        }
    }

    public void setName(String str){
        this.name = str;
    }
    public  String getName(){
        return name;
    }
//    public void setName(String name){
//        this.name = name;
//    }
    public void speak(){
        System.out.println(name + age + "讲话！！！");
    }
    public void say(Student student){
        System.out.println("学生类");
    }
    public void testThis(){
        System.out.println(this);
    }
}

 二、构造器

构造方法——构造器(Constructor)

 

构造方法：

1. 方法名字和类名一样，不允许修改，不需要写return
2. 没有返回值类型，void不能写
3. 方法的重载 ：方法名一样，入参不一样，返回值类型不一样。代码的复用性高
4. 运行：只要new对象，就运行，不允许手动调用，在new对象时，只运行一次
5. 作用：建立对象的同时，给对象初始化
6. 默认构造方法：类名一样，没有参数的构造方法，如果手动写了，编译的时候就不会添加默认方法

 

//无参构造方法：

People p = new People();

 

//有参构造方法：

People p = new People(10);

 

编写方法：

class People{

People(){

//无参构造方法（）没有参数

 

}

People(int age){

//有参构造方法(int age)有参数

}

}

 

例：

package Zsh.SuiSui03;
/*
    构造方法
 */

public class ConstructorDemoss {
    public static void main(String[] args){
//    Sumss s = new Sumss(10,20);
//    int sum = s.getSum();
//    System.out.println(sum);

    Rectangle re = new Rectangle(5,8);
    int length = re.getlength();
    int square = re.getsquare();
    System.out.println("长方形的周长="+length);
    System.out.println("长方形的面积="+square);
    }
}
    /*
        构造方法——构造器(Constructor)

        构造方法：
            1.方法名字和类名一样，不允许修改，不需要写return
            2.没有返回值类型，void不能写
            3.方法的重载 ：方法名一样，入参不一样，返回值类型不一样。代码的复用性高
            4.运行：只要new对象，就运行，不允许手动调用，在new对象时，只运行一次
            5.作用：建立对象的同时，给对象初始化
            6.默认构造方法：类名一样，没有参数的构造方法，如果手动写了，编译的时候就不会添加默认方法

                //无参构造方法：
                    People p = new People();
                //有参构造方法：
                People p = new People(10);
     */
    /*
        编写方法：
        class People{
                    People(){
                    //无参构造方法（）没有参数

                    }
                    People(int age){
                //有参构造方法(int age)有参数
                }
                }
     */
    class People{
        String name;
        int age;
        People (){
            this("岁岁",20);
        }
        People(String name,int age){
            this.name = name;
            this.age = age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
    }

    class Sumss {
        //定义一个类sum，其中定义一个求两个数据和的方法（用构造方法）
        private int a;
        private int b;
        Sumss (int a, int b){//初始化
            this.a = a;
            this.b = b;
        }
        public int getSum(){
            return a+b;
        }
    }

    class Rectangle {
        //定义长方形类，提供两个方法，计算面积周长
        private int width;
        private int height;

        Rectangle(int x,int y){
            this.width = x;
            //定义一个宽
            this.height = y;
            //定义一个长
        }
        public int getlength(){
            return 2*(this.height+this.width);
        }
        public int getsquare(){
            return this.height*this.width;
        }
    }

 

---

 

 

三、继承：

1.继承的由来

要求：定义学生类（姓名，年龄，学习方法）

定义老师类（姓名，年龄，上课方法）

定义工人类（姓名，年龄，上班方法）

发现三个类中，出现了重复的内容，年龄和姓名

避免重复性，共性抽取出来，放在单独的一个类中，三个类都可以直接使用

让这些类产生关系，继承关系

 

继承：类和类之间的关系

新的关键字 extends （扩展，延伸）

 

格式： class A类 extends B类

A类继承B类

 

Student类，称为Person类的子类

Person类，称为Student类的父类，超类，基类

子类可以直接用父类的成员（不是全部）

 

2.继承的好处：

代码量减少

提高可维护性

继承使类和类之间产生了关系，导致了面向对象的三大特征，多态的诞生

Human h =

支持单继承，一个类只能直接继承一个类，不能同时继承多个类

一个子类只能有一个直接父类

支持多层继承

 

3.继承中的注意事项：

子类可以使用父类的成员（变量，方法），父类私有的子类不可以使用

 

弊端：打破类封装性

 

子类不能继承父类的构造方法：方法名不一样

不要为了继承而继承，继承后拥有父类全部内容

 

4.继承后子类和父类成员的变化

成员变量，构造方法，成员方法

成员变量：

子类有——使用子类自己的

子类没有——使用父类的

子类父类都没有——编译失败

 

方法就近访问原则，变量方法自己有就用自己的

在子类中，访问父类的成员，新的关键字super

变量：super.父类成员

方法：super()

super父类存储空间标识，this

 

例：

package Zsh.SuiSui03;

public class ExtendsDemoss {
    /*
       继承
     */

    public static void main(String[] args) {
//        Students s = new Students();
//        Teachers t = new Teachers();
//        s.name = "如懿";
//        t.name = "魔法小厨娘老师";
//        s.sleep();
//        s.drink();
//        s.eat();
//        t.sleep();
//        t.eat();
//        t.drink();

        Zi zi = new Zi(1);

    }
}

    class Human
    {
        String name;
        public void sleep(){
            System.out.println(name+ " 睡觉 ");
        }
        public void eat(){
            System.out.println(name+ " 吃饭 ");
        }
        public void drink(){
            System.out.println(name+ " 喝水 ");
        }
    }
    class Students extends Human
    {

    }
    class Teachers extends Human
    {

    }

    class Fu
    {
        String name;
        int age;
        Fu(){
            System.out.println("这是父类的无参构造方法");
        }
        Fu(int age){
            System.out.println("这是父类的有参构造方法" + age);
        }
    }

    class Zi extends Fu
    {
        String name;
        Zi(){
            System.out.println("这是子类的无参构造方法");
        }
        Zi(int age){
            super(1);
            System.out.println("这是子类的有参构造方法" + age);
        }

//        public void say(String name){
//            System.out.println(name);
//        }
    }