JavaDay3

面向对象

把大象装进冰箱：

​ 1、Java语言通过一个类来描述生活中的事物

​ 2、有哪些类？

​ 如上：大象类、冰箱类、冰箱装大象组合类。

​ 3、类中有什么？

​ 属性和行为

​ 4、类与类的关系是什么?

​ 继承关系

面向对象开发：

​ 创建对象、使用对象、指挥对象

​ 特征：封装、继承、多态

一个Java文件中可以写多个类，但只有一个类能被public修饰，且这个类和Java文件名保持一致。

当看到一个类作为方法的参数类型时，将来调用时需要传入该类或者该类的子类的对象。

1、方法中的变量使用顺序遵循就近原则

2、Java中提供了个关键字this，使用this关键字，可以在方法中使用当前对象里其它成员

​ 使用 this.变量名 不考虑就近原则

构造方法

创建对象时所调用的方法

特点：方法名和类名保持一致，无返回值，无void

注意：1、若未自行去写构造方法，默认JVM会提供一个无参无方法体的构造方法

​ 2、若写了，无论无参或有参，则JVM将不会再提供构造方法

​ 3、构造方法也是方法，也可以发生重载。

​ 4、可利用构造方法可以传参的特性，对参数进行赋值。

关键字static

/*
    java中提供了一个关键字：static 可以表示一个类多个对象共享一个成员

    可以修饰成员变量和成员方法
    注意事项：
        1、被static修饰的成员称之为类成员，静态成员，不被任何一个对象私自拥有
        2、类成员是可以直接通过类名的方式进行访问获取，优先于对象而存在的
        3、非静态的成员方法既可以访问非静态的成员，也可以访问静态的成员
        4、静态的成员方法只能访问静态的成员


 */

继承extends

package shujia.day05;

/*
    java提供了一个关键字表示继承， extends
    class 子类 extends 父类{

    }

    class A extends B{

    }

    A：子类，派生类
    B：父类，超类，基类
 */
class Person2{
    String name;
    int age;

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

    public void study(){
        System.out.println("学习");
    }
}

class Student2 extends Person2{
//    String name;
//    int age;
//
//    public void eat(){
//        System.out.println("吃饭");
//    }
//
//    public void study(){
//        System.out.println("学习");
//    }
}

class Teacher2 extends Person2{

}

public class PersonDemo2 {
    public static void main(String[] args) {
        Student2 student2 = new Student2();
        student2.name = "张三";
        student2.age = 18;
        System.out.println(student2.name+"--"+student2.age);
        student2.eat();
        student2.study();
    }
}

package shujia.day05;

/*
    使用继承的注意事项：
        1、不要有一点相同的部分就使用继承
            class A{
                fun1();
                fun2();
                fun3();
            }

            class B{
                fun2();
                fun5();
                fun6();
            }

           什么时候使用继承呢？两个类之间满足英语语法上的is a关系就可以了。

        2、子类无法继承父类中的私有成员【私有的成员变量或私有的成员方法】
        3、构造方法无法继承
        4、子类继承父类之后，子类中可以编写自己特有的功能和属性
        5、一个类同一时刻只能继承一个类，不允许一次继承多个类，但是可以多重继承，形成继承体系
 */



class Fu {
    int a = 10;
    static int b = 20;
    private int c = 30;

//    Fu(){
//
//    }

    public void show1(){
        System.out.println("这是父类中的成员方法show1");
    }

    public static void show2(){
        System.out.println("这是父类中的成员方法show2");
    }
    private void show3(){
        System.out.println("这是父亲私有的成员方法show3");
    }
}

class Zi extends Fu {
    //int a = 10;
    //static int b = 20;
    int d = 100;

//    public void show1(){
//        System.out.println("这是父类中的成员方法show1");
//    }
//
//    public static void show2(){
//        System.out.println("这是父类中的成员方法show2");
//    }

//    Fu(){
//
//    }
    public void fun1() {
        System.out.println(a);
        System.out.println(b);
        show1();
        show2();
//        show3();
//        System.out.println(c);
    }
}

public class ExtendsDemo1 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.fun1();

//        zi.show1();
//        Zi.show2();
    }
}

//不允许继承多个类

package shujia.day05;

/*
    继承和成员变量的关系:【就近原则】
    先在方法内部->当前类的成员变量位置->父亲的成员变量

    java提供了一关键字super可以在子类中使用直接父类中的非私有的成员【成员变量，构造方法，成员方法】

    面试题：super和this的区别？


 */

class GrandFu3{
    int b = 100;
}
class Fu3 extends GrandFu3{
    //int b = 100;
    int a = 10;
}

class Zi3 extends Fu3 {
    //int b = 100;
    int a = 20;
    public void fun1() {
        int a = 30;
        int b = 200;
        System.out.println(a);
        System.out.println(this.a);
        System.out.println(super.a);
//        System.out.println(super.super.b); //无法使用super获取到间接父类中的成员

        System.out.println(b);
        GrandFu3 grandFu3 = new GrandFu3();
        System.out.println(grandFu3.b);
    }
}

public class ExtendsDemo3 {
    public static void main(String[] args) {
        Zi3 zi3 = new Zi3();
        zi3.fun1();
    }
}

package shujia.day05;

/*
    继承和构造方法的关系：
        1、子类的构造方法第一句默认会有一个super()， 调用的是父亲中的无参构造方法
        2、要想初始化子类，必须先初始化其父类
        3、无论子类构造方法第一句话调用的是父类中有参构造方法还是无参构造方法，都是对父亲的初始化
        4、java中的类不允许多次初始化
        5、子类构造方法中对父亲初始化的代码必须是第一句话

 */
class Fu4 {
//    Fu4(){
//        System.out.println("这是父亲中的构造方法。。。");
//    }

    Fu4(String n) {
        System.out.println("这是父亲中的有参构造方法。。。" + n);
    }
}

class Zi4 extends Fu4 {
    Zi4() {
        //super(); // 调用的是父亲中的无参构造方法
        super("hello");
        System.out.println("这是子类中的构造方法，，，");
//        super("hello");
    }

}

public class ExtendsDemo4 {
    public static void main(String[] args) {
        Zi4 zi4 = new Zi4();
    }
}

package shujia.day05;

/*
    继承和成员方法的关系：
        方法的重写：在继承关系中，子类中的方法声明【返回值类型，方法名，参数列表】与父类中的一模一样，只是方法实现不一样，这个现象成为方法的重写
        方法的重载：在同一个类中，方法名一样，参数列表不同现象，方法的重载，与返回值无关。


    面试题：方法的重载和重写什么区别？

    注意：并不是所有的方法子类都能重写？
        1、父类中静态的方法子类无法重写。可以继承使用父亲的静态成员，不能重写。
        2、父类中的私有方法子类无法重写，私有的都无法继承，更不用想重写了。
        3、重写和权限有关系吗？ public protected 默认的 private
            子类重写的方法权限不能比父亲的还要低 可以是大于等于，推荐除特殊要求外，保持一致

 */
class Fu6{
    protected void fun1(){
        System.out.println("这是父类中的fun1方法");
    }

    public static void fun2(){
        System.out.println("这是父类中的静态的fun2方法");
    }

    private void fun3(){
        System.out.println("这是父类中的私有的fun3方法");
    }

}

class Zi6 extends Fu6{
//    public void fun1(){
//        System.out.println("这是父类中的fun1方法");
//    }

    @Override
    protected void fun1(){
        System.out.println("好好学习，天天向上！");
    }

    //无法重写
//    public static void fun2(){
//        System.out.println("数加666");
//    }
//
//    @Override
//    private void fun3(){
//        System.out.println("数加666");
//    }

    public void show1(){
        fun1();
    }

    public int show1(String n){
        return 10;
    }
}

public class ExtendsDemo5 {
    public static void main(String[] args) {
        Zi6 zi6 = new Zi6();
        zi6.show1();
        zi6.fun1();
    }
}

关键字final

package shujia.day05;

/*
    子类可以重写父类中非私有，非静态的方法

    新需求：只允许子类使用父类中的非私有，非静态的方法，不允许重写，一旦重写就会报错

    java提供了一个关键字给我们使用final
    final: 最终的，不可改变的
    可以修饰类，变量，成员方法
    修饰成员方法：方法不能被重写，可以被继承使用
    修饰成员类：被final所修饰的类，类不能被继承
    修饰变量：被final所修饰的变量，变量变常量，不能修改变量的值。

    final修饰的变量赋值的时机：必须在构造方法完毕之前赋值，否则程序报错。



 */

//final class F{
//
//}
//
//class Z1 extends F{
//
//}

class Fu7{
    public final void show(){
        System.out.println("这是父类中的非私有，非静态的方法show");
    }
}

class Zi7 extends Fu7{
    final int A = 11;

    public void fun1(){
//        A = 12;
        System.out.println(A);
    }

//    @Override
//    public void show(){
//        System.out.println("已重写父亲的方法show");
//    }
}

class Demo2{
    int a = 10;
}

class Demo3{
    final int a;

    //使用构造代码块给final修饰的变量赋值，优先于构造方法执行
//    {
//        a =100;
//    }

    //可以在构造方法执行过程中进行赋值
    Demo3(){
        a = 200;
    }

}

public class ExtendsDemo6 {
    public static void main(String[] args) {
//        Zi7 zi7 = new Zi7();
//        zi7.show();
//        zi7.fun1();
//        Math.PI

//        final Demo2 d1 = new Demo2(); // 修饰引用数据类型变量，指的是地址值不能被修改
//        System.out.println(d1.a);
//        d1.a = 100;
//        System.out.println(d1.a);
//        d1 = new Demo2();

    }
}

多态

package shujia.day06;

/*
    多态：某一个事物，在不同时刻下的不同状态
    实现多态有3个前提：
        1、必须要有继承关系
        2、要有方法的实现
        3、要有父类的引用指向子类对象

    水：气态的水，固态的水，液态的水
    水果：苹果，香蕉，哈密瓜
    动物：狗，猫

 */
class Animal{
    String name;
    int age;

    Animal(){

    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public void sleep(){
        System.out.println("睡觉");
    }
}

class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
        public void eat(){
            System.out.println("

标签：JavaDay3,void,System,class,println,public,out	

From： https://www.cnblogs.com/Roxan-bd/p/18650818