JavaSE进阶回顾第一天

80 阅读 0 评论 53 点赞

我是靠谱客的博主糊涂小海豚，这篇文章主要介绍JavaSE进阶回顾第一天，现在分享给大家，希望可以做个参考。

第一章

final关键字
抽象类
接口
抽象类与接口的区别
package和import
访问权限控制
Object类

final的特点：

final修饰的类，为最终类，该类不能被继承。(如String 类)
final修饰的方法可以被继承和重载，但不能被重写
final修饰的变量不能被修改，只能被赋值一次。
final修饰的引用只能指向一个对象，并且它只能永远指向该对象。

万变不离其宗。final修饰的变量只能被赋值一次！

final修饰实例变量，那么在构造方法初始化该属性后，就不能被修改了。final修饰的实例变量，系统不会赋默认值，必须要程序员手动赋初值，或者通过构造方法赋值！！！

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class User{
    //实例变量
    //编译器报错！！！
    final int age;
    
    //实例变量
    //编译通过
    final double height=1.8;
    
    //实例变量
    //通过构造方法赋值可以通过
    final double weight;
    
    //构造方法
    public User(){
        this.weight=60;
    }
    
}

static final修饰的被称为常量。

常量与静态变量区别在于：常量是不能改变的。

常量和静态变量都存储在方法区，并且都在类加载的时候初始化。

常量全大写

复制代码

1
2
3
4
5
6
class Chinese{
    static final String COUNTRY = "中国";
    
    static final int i = 10;
}

在这里插入图片描述

抽象类

什么是抽象类？

类与类之间具有共同特征，将这些共同特征提取出来。形成的就是抽象类。类本身是不存在的，所以抽象类无法创建对象《无法实例化》。
抽象属于什么类型？

抽象类属于引用数据类型。
抽象类怎么定义？

复制代码

1
2
3
4
5
6
7
8
9
10
//银行账户类
abstract class Account{
   
} 

//子类继承抽象类，子类可以实例化对象
class CreditAccount extends Account{
    
}

抽象类的子类可以是抽象类。
注意:abstract和final是敌人，不能同时出现，不能联合使用。（abstract类就是为被继承，而final修饰的类不能被继承）
抽象类虽然无法实例化，但抽象类有构造方法，这个构造方法是供子类使用的。
抽象类关联到一个概念：抽象方法。

什么是抽象方法？

抽象方法表示没有实现的方法，没有方法体的方法。
复制代码public abstract void doSome();//抽象方法00
```
1
2
public abstract void doSome();//抽象方法00
```
重点结论如下：
1. 抽象类中不一定有抽象方法。抽象方法必须重写抽象类中。
2. 一个非抽象类继承抽象类，必须将抽象类中的抽象方法实现了/重写/覆盖。

在这里插入图片描述

继承抽象方法可以使用多态
复制代码Animal a = new Bird(); a.move();
```
1
2
3
Animal a = new Bird();
a.move();
```

在这里插入图片描述

接口

接口的基础语法：

接口也是一种引用数据类型。
接口是完全抽象的。
接口定义，语法是什么?

复制代码

1
2
[访问修饰符] interface 接口名{}

一个接口可以继承多个接口，接口支持多继承。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//定义接口
interface A(){
    
}

//定义接口
interface B(){
    
}

//定义接口
interface C extends A,B{
    
}

接口中只包含看两部分，一部分是：常量，一部分是：抽象方法。
接口中所有的元素都是public修饰的。（都是公开的。）
接口的抽象方法的public abstrac可以省略，常量的public static final也可以省略。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//我的数学接口
interface MyMath{
    
    //常量
    public static final double PI=3.14；
        
    //常量的public static final也可以省略
    double PI=3.14； 
    
    //抽象方法
    public abstract int sum(int a,int b);
    
    //接口当中既然都是抽象方法，那么在编写代码的时候，public abstrac可以省略！！
    int sum(int a,int b);
}

接口中的方法都是抽象方法，所有接口中的方法不能有方法体。
经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。但是一定要注意，运行时间可能会出现ClassCastException异常。
向下转型用instanceof同样适用。(代码如下)

以下代码编译没问题，运行有问题：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
interface K{
    
}
interface M{
    
}
interface E implements M{
     
}

M m = new E();

if(m instanceof K){//这样就可以防止没有继承关系的时候可以强转的风险。
    K k = (K)m;
}

以下代码可以通过：调用其他接口中的方法需要转型即可。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface A{
    int m1();
}
interface B{
    int m2();
}
interface C{
    int m3();
}
class D implements A,B,C{
    //实现以上所有方法
}
A a = new D();
B b = new D();
C c = new D();

B b2 = (B)a;//调用其他接口中的方法需要转型即可。
b2.m2

extend在前，implements在后。
一个非抽象类实现接口的时候，必须将接口中所有的方法加以实现。
一个类可以实现多个接口。
使用接口写代码的时候，可以使用多态(父类引用指向子类引用)。

接口在开发中的应用：

注意：接口在开发中的作用，类似于多态在开发中的作用。

多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*public class Master{
    public void feed(Dog d){}
    public void feed(Cat c){}
}*/

public class Master{
    public void feed(Animal a){
        //面向Animal父类编程，父类比子类更抽象
        //所以我们叫做面向抽象编程，不要面向具体编程。
        //这样扩展力就更强。
    }

}

接口是完全抽象的，提倡面向接口编程。

示例：顾客去餐馆吃饭？

复制代码

1
2
3
4
5
6
7
8
//菜单:接口
public interface FoodMenu {
    void chaoFan();//炒饭

    void baoTang();//煲汤

}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
//中国厨师
public class ChineseCook implements FoodMenu{
    @Override
    public void chaoFan() {
        System.out.println("中式炒饭");
    }

    @Override
    public void baoTang() {
        System.out.println("中式煲汤");
    }
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
//外国厨师
public class ForeignCook implements FoodMenu{
    @Override
    public void chaoFan() {
        System.out.println("西式炒饭");
    }

    @Override
    public void baoTang() {
        System.out.println("西式煲汤");
    }
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//顾客
public class Customer {
    //顾客手里有一个菜单
    //Customer has a FoodMnue
    //记住：以后凡是能够使用has a描述的，统一以属性的方式存在！
    private FoodMenu foodMenu;//面向抽象编程，面向接口编程。

    public Customer() {
    }
 
    public Customer(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

    public void chaoFan(){
        foodMenu.chaoFan();
    }
    public void baoTang(){
        foodMenu.baoTang();
    }
}
/*
    Cat is a Animal，但凡满足is a的表示可以设置为继承！
 */

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//主类
public class Test {
    public static void main(String[] args) {
        ChineseCook chineseCook = new ChineseCook();
        Customer customer = new Customer(chineseCook);
        customer.chaoFan();
        customer.baoTang();

        Customer customer1 = new Customer(new ForeignCook());
        customer1.chaoFan();
        customer1.baoTang();
    }
}

类型和类型之间的关系：

is a、has a、like a

is a：Cat is a Animal

凡是能够满足is a的表示"继承关系"
has a：Customer has a menu

凡是能够满足has a关系的通常以"属性"形式存在。

like a：Cook like a FoodMenu

凡是能够满足like a关系的表示：类实现了接口。

抽象类和接口有什么区别？

接口是半抽象的。

接口是完全抽象的。

抽象类中有构造方法。

接口中没有构造方法。

接口与接口之间支持多继承。

类与类之间只支持单继承。

一个类可以实现多个接口。

一个抽象类只能继承一个类(单继承)。

接口中只出现常量和抽象方法。

package和import

package命名规范：

公司域名倒序(com.chinsoft) + 项目名(javas e) + 模块名(chapter17) + 功能名(homework)

例如:com.chinsoft.javase.chapter17;

import:当需要使用的类在不同包下时，需要使用import导包。

java.lang.*这个包下的类不需要使用import导入(*形式的效率低)。

访问控制权限

在这里插入图片描述

范围：public > protected > 默认 > private

Object类

常用的方法:

protected Object clone();//负责对象克隆的。

int hashCode();//获取对象哈希值的一个方法。(通过哈希算法将对象地址转化为一串数字)

boolean equals(Object obj);//判断两个对象是否相等。(自己创建的类建议都重写equals方法)

String toString();//将对象转换成字符串形式

protected void finalize()//垃圾回收器负责调用的方法（垃圾回收器GC回收的时候自动调用，垃圾回收时机）

匿名内部类

什么是内部类？

内部类：在类的内部又定义了一个新的类。被称为内部类。

内部类的分类：

静态内部类：类似于静态变量。

实例内部类：类似于实例变量。

局部内部类：类似于局部变量。

计算方法（匿名内部类实现）:

不建议使用匿名内部类，因为没有名字，不能重复使用，代码太乱，可读性差。

能看懂以后别人写的匿名内部类即可

复制代码

1
2
3
4
5
//计算接口
public interface Compute {
    int sum(int a,int b);
}

复制代码

1
2
3
4
5
6
7
8
//MyMath类
public class MyMath {
    public void mySum(Compute c,int x,int y){
        int retValue =c.sum(x, y);
        System.out.println(x+"+"+y+"="+retValue);
    }
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//主函数入口
//匿名内部类
public class Test {
    public static void main(String[] args) {
        MyMath mm = new MyMath();
        Compute c = new ComputeImpl();
        //mm.mySum(c, 100, 200);
        mm.mySum(new Compute() {//匿名内部类，能看懂即可
            @Override
            public int sum(int a, int b) {
                return a+b;
            }
        }, 100, 200);

    }
}

最后

以上就是糊涂小海豚最近收集整理的关于JavaSE进阶回顾第一天的全部内容，更多相关JavaSE进阶回顾第一天内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：笔记
浏览次数：80 次浏览
发布日期：2023-09-03 06:30:32
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_10_fx_12__7__26_y.html

JavaSE进阶回顾第一天

第一章

final的特点：

抽象类

接口

抽象类和接口有什么区别？

package和import

访问控制权限

Object类

匿名内部类

最后

评论列表共有 0 条评论

发表评论取消回复

JavaSE进阶回顾第一天

第一章

final的特点：

抽象类

接口

抽象类和接口有什么区别？

package和import

访问控制权限

Object类

匿名内部类

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复