Java面向对象，封装，继承的基础练习

1.1面向过程：是一种编程思想，强调的是过程，凡事亲力亲为。

1.2面向对象：是一种编程思想，强调的是结果。

2.面向对象的三大特征：

        1）封装

        2）继承

        3）多态

3.类和对象

       类：是抽象的，类似于类型，我么你可以将其理解为一类事物的模板

        对象：是具体的，是根据类具体创造出来的事物

4.面向对象入门案例

package cn.tedu.oop;
/*本类用于面向对象入门案例
* 在一个Java文件中可以写多个class，但是被public修饰的只能有一个
* 而且这个公共类的名字要求就是当前文件的名字*/
public class TestGreateClass {
    public static void main(String[] args) {
        //4.通过new关键字创建对应类的对象
        Phone p = new Phone();
        //5.通过创建好的对象使用类中的功能
        p.call();
        p.message();
        p.video();
        //6.通过创建好的对象查看属性值
        System.out.println(p.brand);
        System.out.println(p.price);
        System.out.println(p.color);
        System.out.println(p.size);
        //7.创建手机类的第二个对象
        Phone p2 = new Phone();
        System.out.println(p2);
        //8.通过p2对象调用Phone类的三个功能
        p2.video();
        p2.message();
        p2.call();
        //9.给p2对象的属性赋值并查看
        p2.brand = "华为";
        p2.price = 8888.88;
        p2.size = 5.6;
        p2.color = "宝石蓝";
        System.out.println("手机品牌是："+p2.brand);
        System.out.println("手机颜色是："+p2.color);
        System.out.println("手机价格是："+p2.price+"元");
        System.out.println("手机大小是"+p2.size+"寸");

    }
}
//1.通过class关键字创建手机类--用来描述手机这一类事物
//类是一类事物的抽象，用来描述这一类事物的特征与行为
class Phone{
    //特征（属性）--类的成员变量来描述--定义在类方法外的变量
    String brand;//品牌
    double price;//价格
    double size; //尺寸
    String color;//颜色

    //3.定义手机的功能--类的方法来描述--修饰符 返回值类型 方法名（参数列表）{方法体}
    public void call(){
        System.out.println("正在打电话~");
    }
    public void message(){
        System.out.println("正在发短信~");
    }
    public void video(){
        System.out.println("正在看片~");
    }
}

package cn.tedu.oop;
//本类用于面向对象巩固
public class TestCat {
    public static void main(String[] args) {
        Cat m = new Cat();
        m.jump();
        m.miaoMiao();
        System.out.println(m);
        //6.创建小猫的对象2
        Cat m2 = new Cat();
        m2.jump();
        m2.miaoMiao();

        m.name = "黑炭";
        m.age = 3;
        m.hosts = "静静";
        m2.name = "煤球";
        m2.age = 2;
        m2.hosts = "爱丽丝";
        System.out.println("小猫的名字是："+m.name);
        System.out.println("小猫"+m.age+"岁啦~");
        System.out.println("小猫的主人是："+m.hosts);
        System.out.println("小猫的名字是："+m2.name);
        System.out.println("小猫"+m2.age+"岁啦~");
        System.out.println("小猫的主人是："+m2.hosts);
    }
}

//1.通过class关键描述小猫这一类事物
class Cat{
    //2.属性
    String name;
    int age;
    String hosts;
    //3.功能
    public void jump(){
        System.out.println("小猫跳的老高了");
    }
    public void miaoMiao(){
        System.out.println("小猫喵喵叫~~~~");
    }
}

5.面向对象的第一大特性--封装

        封装属性的思路：1.用private修饰资源

                              2.提供公共的get方法，用来获取值

                              3.提供巩固的set方法，用来设置值

        封装方法的思路：1.用private修饰资源

                                     2.用本类的公共方法调用这个被封装方法的功能

package cn.tedu.oop;
/*本类用于继续测试面向对象的第一大特性--封装*/
public class TestPrivate2 {
    public static void main(String[] args) {
        //4.创建学生类对象
        Student s = new Student();
        //5.通过对象操作学生类的属性与方法
        System.out.println(s.name);
        s.study();
        //6.1通过对象修改属性的值，并打印查看
//        s.subject = "java培优";
//        System.out.println(s.subject);
        s.name = "陈平安";
        System.out.println(s.name);
//        s.sno = 20210929;
//        System.out.println(s.sno);
        //6.4 调用自动生成的set与get方法
        s.setSubject("CGB");
        System.out.println(s.getSubject());

        //7.3调用get与set方法操作被封装的属性
        s.setSno(21090929);
        int r = s.getSno();
        System.out.println(s.getSno());

    }
}


//1.使用class关键字描述学生这一类型
class Student{
    //2.学生属性：学号，姓名，科目
    //7.1使用private关键字封装属性
    private int sno;

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    String name;
    //6.2使用private修饰subject属性
    private String subject;
    //右键-Generate-getter and setter-再点那个锁-点ok
    //7.2添加被封装属性的get和set方法

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    //3.学生功能：学习，吃饭，睡觉
    public void study(){
        System.out.println("别吵，学习呢~");
    }
    public void eat(){
        System.out.println("干饭不积极，思想有问题~");
    }
    public void sleep(){
        System.out.println("我一点也不想睡觉，我想学Java");
    }
}

封装的必要性

package cn.tedu.oop;
//本类用于测试封装的必要性
public class TeatPrivate1 {
    public static void main(String[] args) {
        //3.创建对象修改属性值
        User u = new User();
        u.name = "葫芦娃";
        System.out.println(u.name);
        //u.money = 1000000;
        //System.out.println(u.money);
        //6.调用查看余额的方法
        System.out.println(u.getMoney());
        //7.调用设置余额的方法，设置余额为999999
        u.setMoney(999999);
        //设置完，通过获取money的方法再次查看余额值
        System.out.println(u.getMoney());

    }
}

//1.创建一个用户类
class User{
    //2.定义用户类的属性
    public String name; //姓名
    //4.为了更安全的操作余额，修改money的修饰符为private
    /*被private修饰的资源只能在本类中使用*/
    private double money=10000;//账户余额
    //5.1提供公共的方法共外界调用，方法的功能：获取余额
    public double getMoney(){
        /*如果方法的返回值不是void
        * 就需要适应return关键字返回对应类型的返回值*/
        /*后续可以增加权限的验证*/
        return money;
    }
    //5.2提供公共的方法共外界调用，方法的功能：修改余额
    public void  setMoney(double newMoney){
        /*后续可以添加权限的效验*/
        money = newMoney;//将调用方法时传入的值newMoney设置给成员变量money
    }
}

面向对象巩固练习

package cn.tedu.oop;
/*本类用于面向对象的巩固练习*/
public class TestCar {
    public static void main(String[] args) {
        //4.在公共类当中创建汽车类对象
        Car c = new Car();
        //5.设置创建好的对象的属性值
//        c.brand = "BWM";
//        c.color = "黑色";
//        c.price = 300000;
//        c.length = 3.2;
        //6.查看设置好的属性
//        System.out.println(c.brand);
//        System.out.println(c.color);
//        System.out.println(c.price);
//        System.out.println(c.length);
        //7.3操作set方法给所有属性赋值
        c.setBrand("布加迪威龙");
        c.setColor("暗夜黑");
        c.setPrice(40000000);
        c.setLength(3.3);
        //7.4操作get方法查看属性的赋值是否成功
        System.out.println(c.getBrand());
        System.out.println(c.getColor());
        System.out.println(c.getPrice());
        System.out.println(c.getLength());
        //8.通过创建好的对象调用汽车类的功能
        c.start();
        //c.stop();

    }
}
//1.抽象汽车这一类事物的共同点，用class描述
class Car{
    //2.属性--用成员变量来描述
    //7.1封装所有属性
    private String brand;//品牌
    private String color;//颜色
    private double price;//价格
    private double length;//车长

    //3.功能--用方法来描述
    public void start(){
        System.out.println("汽车启动了~");
        //9.2在本类的公共方法里调用被封装的方法
        stop();
    }
    //9.1用private封装汽车停止的方法
    private void stop(){
        System.out.println("汽车停止了~");
    }
    //7.2生成所有属性对应的get和set方法

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }
}

6.构造函数
    格式：与本类名同名，且没有返回值
    作用：创建对象，创建一次，执行一次构造函数
    分类：
        1.无参构造：默认存在，如果添加了其他构造，默认的构造函数会被覆盖
        2.含参构造：对于参数没有任何要求，有参数就行。
        3.全参构造：全参构造的参数必须与本类属性一致
            全参构造不仅可以创建对象，还可以给对象的所有属性赋值
            可以使用idea在类的属性下使用
            鼠标右键-Generate-Constructor-Shift全选所有属性-ok来创建

package cn.tedu.oop;
/*本类用作构造函数的入门案例*/
public class TestConstructor {
    public static void main(String[] args) {
        //4.创建Person类的对象
        /*1.每次new 对象时都会自动触发对应类中的构造方法
        * 2.每一个类中都会默认存在一个没有参数的构造方法
        * 但是，如果你提供了其他的构造函数，默认的无参构造会被覆盖
        * 所以，我们要手动的提供无参构造，这样才能不传参数，也能创建对象*/
        Person p1 = new Person();
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.address);
        p1.eat();
        /*4.每次创建对象都会执行一个构造方法
        * 构造方法的作用：用来创建对象的*/
        Person p2 = new Person(555);
        System.out.println(p2.name);
        /*5.全参构造不仅可以创建对象，还可以给对象的所有属性赋值*/
        Person p3 = new Person("张三",18,"浙江");
        System.out.println(p3.name);
        System.out.println(p3.age);
        System.out.println(p3.address);
    }
}
//1.创建Person类，描述人这一类事物
class Person{
    //2.定义属性
    String name;//姓名
    int age;//年龄
    String address;//地址
    /*3.构造方法的格式：与本来类名同名，且没有返回值类型的方法*/
    //5.1创建本类的无参构造
    public Person(){
        System.out.println("我是Person类的无参构造");
    }
    //5.2创建本类的含参构造--含有参数的构造方法
    public Person(int n){
        System.out.println("我是Person类的含参构造"+n);
    }
    //5.3创建本类的全参构造--此构造函数的参数与本类的属性一致
    //右键-Generate-Constructor-Shift全选所有属性-ok
    public Person(String name, int age, String address) {
        System.out.println("我是Person类的全参构造");
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //3.功能--方法
    public void eat(){
        System.out.println("端起了我的饭盆~");
    }
}

7.代码块
    1.构造代码块：
      ①.位置：类里，方法外
      ②.执行时机：每次创建对象时执行，并且优先于构造方法执行
      ③.作用：用于提取所有构造方法的共同功能
    2.局部代码块：
      ①.位置：方法里
      ②.执行时机：调用本局部代码块所处的方法时执行
      ③.作用：用于控制变量的作用范围

package cn.tedu.oop;
/*本类用于测试代码块
* 执行顺序： 构造代码块>构造方法> 普通方法>局部代码块
* 1.当创建对象时，会触发构造函数
* 2.创建对象时，也会触发构造代码块，并且构造代码块优先于构造方法执行
* 3.我们创建好对象后才能通过对象调用普通方法
* 4.如果普通方法里有局部代码块，才会触发对应的局部代码块*/
public class TestBlock {
    public static void main(String[] args) {
        Pig p1 = new Pig();
        Pig p2 = new Pig("佩奇");
        Pig p3 = new Pig("肉包子",5);
        System.out.println(p1.age);//0，默认值
        System.out.println(p2.age);//0默认值
        System.out.println(p3.age);//5，创建对象时赋值
        p1.eat();
        p2.eat();
        p2.eat();
    }
}
class Pig{
    String food;
    int age;
    {
        /*构造代码块：{}
         * 1.位置：类里，方法外
         * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
         * 3.作用：用于提取所有构造方法的共性功能*/
        System.out.println("我是一个构造代码块");
        System.out.println("黑猪肉");
    }
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
        {
            /*
            * 局部代码块：{}
            1.位置：在方法里
            2.执行时机：调用本局部代码块所处的方法时才会执行，并且构造方法优先于局部代码块执行
            3.作用：用于控制变量的作用范围，变量的作用范围越小越好
            */
            System.out.println("我是一个局部代码块");
            int i = 100;
            System.out.println(i);
        }
        //System.out.println(i);//局部代码块中的局部变量i只能在代码块里使用
    }
    public Pig(){
        System.out.println("我是Pig类的无参构造~");
    }
    public Pig(String s){
        System.out.println("我是Pig类的有参构造"+s);
    }
    public Pig(String food,int age){
        System.out.println("我是Pig类的全参构造");
        this.food = food;
        this.age = age;
    }
}

8.继承extends

package cn.tedu.opp2;

/*本类用于继承的入门案例*/
public class TestExtents {
    public static void main(String[] args) {
        //5.分别创建3个类的对象
        Animal a = new Animal();
        Cat c = new Cat();
        MiaoMiao m = new MiaoMiao();
        //6.利用对象调用方法进行测试
        /*3.继承相当于是子类将父类的功能复制了一份
        继承还具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子
        */
        a.eat();//爷爷类使用自己的方法
        c.eat();//爸爸类可以使用从爷爷类中继承过来的方法
        m.eat();//孙子类也可以使用从爷爷类中继承过来的方法
    }
}
/*1.我们通过extends关键字建立子类与父类的继承关系，格式：子类 extends 父类
* 2.Java只支持单继承，一个子类只能有一个父类，但是一个父类可以有多个子类*/
//1.创建小动物类--爷爷类
class Animal{
    //4.添加爷爷类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }
}
//2.创建小猫类--父类
/*6.继承是is a 的关系，比如小猫是小动物，MiaoMiao是一只小猫
* 继承要求子类必须是父类的一种下属类型，依赖性非常强，强耦合*/
class Cat extends Animal{
    //7.定义爸爸类中的属性
    int a = 10;//普通属性
    private int b = 100;//私有属性
}
//3.创建MiaoMiao类--孙子类
class MiaoMiao extends Cat{
    /*4.子类可以拥有自己独有的方法，实现了功能的拓展，青出于蓝而胜于蓝*/
    //8.定义孙子类的方法
    public void studyJava(){
        System.out.println("正在学java");
        System.out.println(a);
        /*5.子类继承了父类以后，可以使用父类的所有非私有资源
        * 注意：这个私有资源由于被private修饰，所以没有访问权限*/
        //System.out.println(b); //不可以，私有资源被限制访问
    }
}

①this的用法
    1.当成员变量与局部变量同名时，使用this指定成员变量
    2.使用this在构造方法的第一行调用构造方法的功能
      this();--调用的是本类的无参构造
      this(参数);--调用的是父类对应参数的构造方法

package cn.tedu.oop;
/*本类用于this测试*/
public class TestThis1 {
    public static void main(String[] args) {
        //4.创建对象并调用方法
        Cat c = new Cat();
        c.eat();
    }
}
//1.创建小猫类
class Cat{
    //5.创建成员变量
    int count = 666;
    int sum = 100;
    //2.创建方法
    public void eat(){
        //3.创建局部变量
        int sum = 10;
        System.out.println(sum);//10使用的是局部变量，就近原则
        /*当成员变量与局部变量同名时，可以使用this指定本类的成员变量
        如果不使用this指定，打印的就是近处的这个局部变量，就近原则*/
        System.out.println(this.sum);//100
        System.out.println(count);
    }
}

package cn.tedu.oop;
/*本类用于测试this的用法2*/
public class TestThis2 {
    public static void main(String[] args) {
        //3.1触发无参构造创建本类对象
        Dog d1 = new Dog();
        //3.2触发有参构造创建本类对象
        Dog d2 = new Dog("旺财");
    }
}
//1.创建小狗类
class Dog{
    //2.1创建本类无参构造
    public Dog(){
        /*在无参构造中调用含参构造的功能
        * 注意：调用是单向的，不能来回双向调用，否则会死循环*/
        this("小汪汪~");
        System.out.println("我是一个无参构造");
    }
    //2.2创建本类含参构造String s
    public Dog(String s){
        /*在含参构造中，调用无参构造的功能
        * 规定：this关键字必须在构造函数的第一行*/
        //this();
        System.out.println("我是一个含参构造"+s);
    }
}

②super的用法
    1.当父类的成员变量与子类的变量同名时，使用super指定父类的成员变量
    2.使用super在子类构造方法的第一行调用父类构造方法的功能
      super();--调用的是父类的无参构造
      super(参数);--调用的是父类对应参数的构造方法

package cn.tedu.opp2;
/*本类用于测试继承中变量的使用*/
public class TestExtendsDemo1 {
    public static void main(String[] args) {
        //7.创建子类的匿名对象，调用study
        new Son().study();
    }
}
//1.创建父类
class Father{
    //3.创建父类的成员变量
    int sum = 1;
    int count = 2;
}
//2.创建子类
class Son extends Father{
    //4.创建子类的成员变量
    int sum = 10;
    //5.创建子类的普通方法
    public void study(){
        System.out.println("good good study,day day up!");
        //6.创建子类的局部变量
        int sum = 100;
        //8.打印子类的局部变量sum
        System.out.println(sum);//100
        //9.打印子类的成员变量sum
        System.out.println(this.sum);//10
        //10.打印父类的成员变量sum
        /*当父类的成员变量与子类的成员变量同名时，可以使类用super指定父的成员变量
        我们可以把super看作是父类的对象：Father super = new Father();*/
        System.out.println(super.sum);//1
    }
}

package cn.tedu.opp2;
/*本类用于测试继承中构造方法的使用
* 1.子类在创建对象时，默认会先调用父类的构造方法
* 2.原因是子类构造函数中的第一行默认存在super();--表示调用父类的无参构造
* 3.当父类的无参构造被覆盖时，可以通过super(参数)调用父类的其他含参构造
* 子类必须调用父类的构造函数，不管是无参还是含参，选一个即可
* 4.构造方法不可以被继承！因为语法的原因：要求构造方法的类名必须是本类类名，
* 不能在子类中出现一个父类名字的构造方法*/
public class ExtendsDemo2 {
    public static void main(String[] args) {
        //6.1通过父类的无参构造创建父类对象
        //Father2 f = new Father2();
        //6.通过父类的含参构造创建父类对象
        //Father2 f2 = new Father2("哈哈哈");
        //7.创建子类对象
        Son2 s = new Son2();
    }
}
//1.创建父类
class Father2{
    //3.创建父类的无参构造
//    public Father2(){
//        System.out.println("我是父类的无参构造");
//    }
    //4.创建父类的含参构造
    public Father2(String s){
        System.out.println("我是父类的含参构造"+s);
    }
}
//2.创建子类
class Son2 extends Father2{
    //5.创建子类的无参构造
    public Son2(){
        //super();//调用父类的无参构造
        super("您好~");
        System.out.println("我是子类的无参构造");
    }
}