Java-类(类与类直接的关系、抽象类、内部类）

目录

一、类和类之间的关系

 二、final修饰符

三、抽象类，抽象方法

四、内部类

---

一、类和类之间的关系

【1】面向对象的思想：找参与者，找女孩类，找男孩类

【2】体会了什么叫方法的形参，什么叫方法的实参：

需要传入的是形参：

 具体传入的内容是实参：

【3】类和类可以产生关系

1.将一个类作为另一个类中的方法的形参

2.将一个类作为另一个类的属性

Boy类

package com.hhf.test03;


public class Boy {
    //属性
    int age;
    String name;
    //方法
    public void buy(){
        System.out.println("我给你买买买");
    }

    //构造器
    public Boy() {
    }

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

Girl类：

package com.hhf.test03;


public class Girl {
    //属性
    String name;
    double weight;
    Mom m =new Mom();
    //方法
    public void love(Boy b){
        System.out.println("我男朋友的名字是："+b.name+"他的年龄是"+b.age);
        b.buy();
    }

    public void wechat(){
        m.say();
    }

    //构造器

    public Girl() {
    }

    public Girl(String name, double weight) {
        this.name = name;
        this.weight = weight;
    }
}

 Mom类：

package com.hhf.test03;

odified By:
 */
public class Mom {
    public void say(){
        System.out.println("妈妈");
    }
}

 Test：

package com.hhf.test03;


public class Test {
    public static void main(String[] args) {
        //跟男孩谈恋爱
        Boy b =new Boy(30,"蔡徐坤");
        Girl girl=new Girl("迪丽热巴",50);
        girl.love(b);

        //还可以在微信跟妈妈聊天
//        girl.m = new Mom();
        girl.wechat();

    }
}

 二、final修饰符

1.修饰变量：

package finalStudy;


public class Test {
    public static void main(String[] args) {
        //【1】
        //final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗成的规定：名字大写
        final int A = 10;   //final修饰基本数据类型
        //A =  10;报错，不可以修改

        //【2】
        final Dog d = new Dog();    //final修饰引用数据类型，那么地址值就不可以改变
        //d = new Dog();——》地址值不可以改变
        //d对象的属性依然可以改变
        d.age=10;
        d.weight=163.8;

        //【3】
        final Dog d2=new Dog();
        a(d2);

        //【4】
        b(d2);
    }

    public static void a(Dog d){
        d = new Dog();
    }

    public static void b(final Dog d){//d被final修饰，指向不可以改变
        //d=new Dog();——》错误代码
    }
}

2.修饰方法，final修饰方法，那么这个方法不可以被该类的子类重写：

 3.修饰类；final修饰类，代表没有子类，该类不可以被继承；一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了

 4.案例：JDK提供的math类

1.使用math类的时候无需导包，直接使用即可

2.math类没有子类，不能被其他类继承了

3. 里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写了。原因：子类没有必要进行重写

4.外界不可以创建对象：Math m=new Math();

5.发现math类中的所有属性，方法，都被static修饰，那么不用创建对象去调用，只能通过类名.属性名，类名.方法名 去调用

三、抽象类，抽象方法

1.抽象类和抽象方法的关系：抽象类中可以定义0-N个抽象方法。

2.抽象类作用：在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。

抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。使子类更加的通用

3.代码演示：

package chouXiangLeiYuFangFa;

//4.一个类中如果有抽象方法，那么这个类也要变成一个抽象类.
//一个抽象类中可以有0-N个抽象方法
public abstract class Person {
    //1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
    public void eat() {
        System.out.println("一顿不吃饿得慌");
    }

    //在一个类中，会有一类方法，子类对这个1方法永远不满足，会对这个方法进行重写
    //3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了有一个抽象方法
    public abstract void say();

    public abstract void sleep();
}
//6.抽象类可以被其他类继承：
//7.一个类继承抽象类，那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰，一般让子类重写父类中的抽象方法
//9.子类继承抽象类，就必须重写全部的抽象方法
//10.子类如果没有重写父类的抽象方法，那么子类也可以变成一个抽象类
class Student extends Person {
    @Override
    public void say() {
        System.out.println("我是客家人，我讲客家话");
    }

    @Override
    public void sleep() {
        System.out.println("正午时分");

    }
}

class Demo{
    public static void main(String[] args) {
        //11.创建抽象类的对象:————》抽象类不可以创建对象
//        Person p = new Person();

        //12.创建子类对象：
        Student s=new Student();
        s.say();
        s.sleep();


        //13.多态的写法：父类引用指向子类对象：
        Person p = new Student();
        
    }
}

4.面试题：

问：抽象类不能创建对象，那么抽象类中是否有构造器？

答：抽象类中一定有构造器。构造器的作用：给其他子类初始化对象的时候要先super调用父类的构造器。

问：抽象类是否可以被final修饰？

答：不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类

四、内部类

1.成员内部类：

package com.hhf.test07;


 * 1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
 * 2.一个类（TestOutter）的内部的类（SubTest）叫内部类，内部类:SubTest   外部类：TestOutter
 * 3.内部类：成员内部类（静态的，非静态的）  和   局部内部类（位置：方法内，块内，构造器内）
 * 4.成员内部类：
 *      里面有属性，方法，构造器等
 *      修饰符：private，default，protect，public，final，abstract
 */
public class TestOutter {
    //非静态的成员内部类：
    class D{
        int age =20;
        String name;
        public void method(){
            //5.内部类可以访问外部类的内容
            /*System.out.println(age);//可以访问外面的属性
            a();//可以调用外面的方法*/
            int age =30;
            //8.内部类和外部类重名的时候，如何进行调用：
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOutter.this.age);//10
        }

    }
    //静态成员内部类：
    static class E{
        public void method(){
            //6.静态内部类中只能访问外部类中被static修饰的内筒
            /*System.out.println(age);
            a();*/
        }

    }
    //属性：
    int age=10;
    //方法：
    public void a(){
        System.out.println("这是a方法");
        {
            System.out.println("这是一个普通块");
            class B{
                //局部内部类放在块中
            }
        }
        class A{//局部内部类放在方法内

        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        D d=new D();
        System.out.println(d.name);
        d.method();
    }
    static {
        System.out.println("这是静态块");
    }
    {
        System.out.println("这是构造器，先执行构造块，再执行构造器");
    }
    //构造器：
    public TestOutter(){
        class C{
            //局部内部类放在构造器中
        }

    }

    public TestOutter(int age) {
        this.age = age;
    }
}

class Demo{
    public static void main(String[] args) {
        //8.创建外部类对象
        TestOutter to = new TestOutter();
        to.a();

        //9..创建内部类的对象：
        //静态的成员内部类创建对象
        TestOutter.E e=new TestOutter.E();

        //非静态的成员内部类创建对象
        //错误：TestOutter.D d=new TestOutter.D();
        //正确
        TestOutter t = new TestOutter();
        TestOutter.D d=t.new D();

    }
}

2.局部内部类：

package com.hhf.test08;


public class TestOuter {
    //1.在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
        final int num=10;
        class A{
            public void a(){
                //num=20;
                System.out.println(num);
            }
        }
    }
    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
    public Comparable method2(){
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 1000;
            }
        }
        return new B();
    }
    public Comparable method3(){
        //3.匿名内部类
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        };
    }
    public void test(){
        Comparable com = new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 300;
            }
        };
        System.out.println(com.compareTo("abc"));
    }

}