JAVA初记笔记面向对象18（4）

最新推荐文章于 2022-05-10 23:44:32 发布

原创最新推荐文章于 2022-05-10 23:44:32 发布 · 285 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java

JAVA初级笔记专栏收录该内容

6 篇文章

订阅专栏

18、面向对象（4）

1、类和类之间的关系(1)

public class Girl {
        //属性：
        String name;
        double weight;
        Mom m /*= new Mom()*/;
        //方法：
       /*
        public void add(int a){//参数是基本数据类型
            System.out.println(a);
            System.out.println(a+100);
        }

        */
        //谈恋爱的方法：
        public void love(Boy b){//参数是引用数据类型Boy
            System.out.println("我男朋友的名字是："+b.name+"，我男朋友的年龄是："+b.age);
            b.buy();
        }
        //女孩跟妈妈聊天：
        public void wechat(){
            m.say();
        }
        //构造器：
        public Girl(String name, double weight) {
            this.name = name;
            this.weight = weight;
        }
    }

public class Boy {
    //属性：
    int age;
    String name;
    //方法：
    public void buy(){
        System.out.println("跟我谈恋爱，我给你买买买。。。");
    }
    //构造器：
    public Boy(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

public class Mom {
    //方法：
    public void say(){
        System.out.println("妈妈唠唠叨叨 都是爱，听妈妈的话。。");
    }
}

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Boy类的具体的对象：
        Boy boy = new Boy(30,"鹿晗");
        //创建一个Girl类的具体的对象：
        Girl girl = new Girl("关晓彤",100);
        //谈恋爱：
        //girl.love(boy);
        Boy boy2 = new Boy(35,"陈伟霆");
        girl.love(boy2);
        //还可以跟妈妈微信聊天：
        girl.m = new Mom();
        girl.wechat();
    }
}

总结：
(1)、面向对象的思维：找参与者，找女孩类，找男孩类
(2)、体会了什么叫方法的形参，什么叫方法的实参：
在这里插入图片描述
(3）、具体传入的内容实参：

(4)、类和类可以产生关系：
1）、将一个类作为另一个类中的方法的形参
2）、将一个类作为另一个类的属性

2、类和类之间的关系(2)

3、final修饰符

（1）、修饰变量；

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //第1种情况：
        //final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
        final int A = 10;//final修饰基本数据类型
        //A = 20; 报错：不可以修改值
        //第2种情况：
        final Dog d = new Dog();//final修饰引用数据类型，那么地址值就不可以改变
        //d = new Dog(); -->地址值不可以更改
        //d对象的属性依然可以改变：
        d.age = 10;
        d.weight = 13.7;
        //第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修饰了（final可以省略不写）

（4）、案例：JDK提供的Math类：看源码发现：
1）使用Math类的时候无需导包，直接使用即可：
在这里插入图片描述
2）Math类没有子类，不能被其他类继承了

3）里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写了
原因：子类没有必要进行重写。
4）外界不可以创建对象：
Math m = new Math();

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

4、抽象类_抽象方法

package com.msb.test03;
//4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
public abstract class Person {
    //1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
    public void eat(){
        System.out.println("一顿不吃饿得慌");
    }
    //2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
    //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{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //11.创建抽象类的对象：-->抽象类不可以创建对象
        //Person p = new Person();
        //12.创建子类对象：
        Student s = new Student();
        s.sleep();
        s.say();
        
        //13.多态的写法：父类引用指向子类对象：
        Person p  = new Student();
        p.say();
        p.sleep();
    }
}

（1）、
1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
5.一个抽象类中可以有0-n个抽象方法
6.抽象类可以被其他类继承：
7.一个类继承一个抽象类，那么这个类可以变成抽象类
8.一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
9.子类继承抽象类，就必须重写全部的抽象方法
10.子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。
11.创建抽象类的对象：–>抽象类不可以创建对象
12.多态的写法：父类引用指向子类对象：

（2）、抽象类和抽象方法的关系：
抽象类中可以定义0-n个抽象方法。

（3）、抽象类作用：
在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。
使子类更加的通用。

（4）、注：
1）抽象类不能创建对象，那么抽象类中是否有构造器？
抽象类中一定有构造器。构造器的作用给子类初始化对象的时候要先super调用父类的构造器。
2）抽象类是否可以被final修饰？
不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。

5、接口（JDK1.8之前）

package com.msb.test04;
/**
 * 1.类是类，接口是接口，它们是同一层次的概念。
 * 2.接口中没有构造器
 * 3.接口如何声明：interface
 * 4.在JDK1.8之前，接口中只有两部分内容：
 * （1）常量：固定修饰符：public static final
 * （2）抽象方法：固定修饰符：public abstract
 * 注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
 */
public interface TestInterface01 {
    //常量：
    /*public static final*/ int NUM = 10;
    //抽象方法：
    /*public abstract*/ void a();
    /*public abstract*/ void b(int num);
    /*public abstract*/ int c(String name);
}
interface TestInterface02{
    void e();
    void f();
}
/*
5.类和接口的关系是什么？ 实现关系  类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02
 */
class Student extends Person implements TestInterface01,TestInterface02 {
    @Override
    public void a() {
        System.out.println("---1");
    }
    @Override
    public void b(int num) {
        System.out.println("---2");
    }
    @Override
    public int c(String name) {
        return 100;
    }
    @Override
    public void e() {
        System.out.println("---3");
    }
    @Override
    public void f() {
        System.out.println("---4");
    }
}
class Test{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //10.接口不能创建对象：
        //TestInterface02 t = new TestInterface02();
        TestInterface02 t = new Student();//接口指向实现类 ---》多态
        //11.接口中常量如何访问：
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);
    }
}

1.类是类，接口是接口，它们是同一层次的概念。
2.接口中没有构造器
3.接口如何声明：interface
4.在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符：public static final
（2）抽象方法：固定修饰符：public abstract
注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
5.类和接口的关系是什么？实现关系类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9.写法：先继承再实现：extends Person implements TestInterface01,TestInterface02
10.接口不能创建对象

（1）、接口语法结构：
[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {
常量定义；
方法定义；
}
（2）、接口的作用是什么？

定义规则，只是跟抽象类不同地方在哪？它是接口不是类。
接口定义好规则之后，实现类负责实现即可。
（3）、
继承：子类对父类的继承
实现：实现类对接口的实现
（4）、
多态的应用场合：
1）父类当做方法的形参，传入具体的子类的对象
2）父类当做方法的返回值，返回的是具体的子类的对象
3）接口当做方法的形参，传入具体的实现类的对象
4）接口当做方法的返回值，返回的是具体的实现类的对象
5）、接口和抽象类的区别：
在这里插入图片描述

6、接口（JDK1.8之后新增）

public interface TestInterface {
    //常量：
    public static final int NUM= 10;
    //抽象方法：
    public abstract void a();
    //public default修饰的非抽象方法：
    public default void b(){
        System.out.println("-------TestInterface---b()-----");
    }
}
class Test implements TestInterface{
    public void c(){
        //用一下接口中的b方法：
        b();//可以
        //super.b();不可以
        TestInterface.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    @Override
    public void b() {
    }
}

（1）、
在JDK1.8之前，接口中只有两部分内容：
1）常量：固定修饰符：public static final
2）抽象方法：固定修饰符：public abstract

在JDK1.8之后，新增非抽象方法：
1）被public default修饰的非抽象方法：
注意1：default修饰符必须要加上，否则出错
注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。

public interface TestInterface2 {
    //常量：
    public static final int NUM = 10;
    //抽象方法：
    public abstract  void a();
    //public default非抽象方法；
    public default void b(){
        System.out.println("-----TestInterface2---b");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}
class Demo implements TestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}
class A {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();
        TestInterface2.c();
    }
}

（1）、静态方法：
注意1：static不可以省略不写
注意2：静态方法不能重写
（2）、为什么要在接口中加入非抽象方法？？？
如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响。
现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。

7、内部类_成员内部类

package com.msb.test07;
/**
 * 1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
 * 2.一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest  外部类：TestOuter
 * 3.内部类：成员内部类 (静态的，非静态的) 和  局部内部类（位置：方法内，块内，构造器内）
 * 4.成员内部类:
 *      里面属性，方法，构造器等
 *      修饰符：private，default，protect，public，final,abstract
 */
public class TestOuter {
    //非静态的成员内部类：
    public 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(TestOuter.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 TestOuter(){
        class C{
        }
    }
    public TestOuter(int age) {
        this.age = age;
    }
}
class Demo{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建外部类的对象：
        TestOuter to = new TestOuter();
        to.a();
        //9.创建内部类的对象：
        //静态的成员内部类创建对象：
        TestOuter.E e = new TestOuter.E();
        //非静态的成员内部类创建对象：
        //错误：TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d = t.new D();
    }
}

1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
2.一个类TestOuter的内部的类SubTest叫内部类，内部类：SubTest 外部类：TestOuter
3.内部类：成员内部类 (静态的，非静态的) 和局部内部类（位置：方法内，块内，构造器内）
4.成员内部类:
里面属性，方法，构造器等
修饰符：private，default，protect，public，final,abstract
5.内部类可以访问外部类的内容
6.静态内部类中只能访问外部类中被static修饰的内容
7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
8.内部类和外部类属性重名的时候，如何进行调用：

8、内部类_局部内部类

package com.msb.test08;
/**
 * @Auther: msb-zhaoss
 */
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 100;
            }
        }
        return new B();
    }
    public Comparable method3(){
        //3.匿名内部类
        return new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }
    public void teat(){
        Comparable com = new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
        System.out.println(com.compareTo("abc"));
    }
}