Java随堂笔记

代码中出现的高频单词

Type 类型
mismatch 不匹配
switch 转换
local 局部
variable 变量
initialized 初始化赋值
resolved 引用使用
reference 引用调用
Duplicate 重复的
Auto-generated 自动生成
Unreachable code 不可到达代码
declared 声明定义
access权限
already 已经
defined 定义
scope 范围

inherit 继承

分支结构

单分支
if（判断条件）{
代码
}

多分支1
if（判断条件）{
满足条件代码1
}else{
不满住条件代码2
}

嵌套分支
if（判断条件1）{
代码
}else if(判断条件2){
代码
}else{
代码
}

switch （valuce）{
case valuce1 sout();break;
case valuce2 sout();break;
case valuce3 sout();break;
case valuce4 sout();break;
case valuce5 sout();break;
default sout();
}

循环结构

for(开始条件；循环条件；更改条件）{
循环体；
}

典型案例：冒泡排序

方法结构

类型名称字节空间默认值取值名称

方法的格式：

修饰符返回值类型方法名（参数列表）{
方法体

}

面向对象的三大特征

封装

封装：把相关的数据封装成一个“类”组件

封装可以提高程序的安全性
封装可以让资源按照我们预先规定的方式来操作

继承：子类共享父类的属性和方法
多态：增强软件的灵活性和重用性

TIPS：栈和队列指的是一种数据的结构
栈：先进后出（FILO –First In Last Out）
队列：先进先出（FIFO– First In First Out）

Phone p =new Phone()；这句代码，在内存中会发生什么/p>

new Phone()；在栈里栈内存中开辟一块空间并提供一个地址值 Phone p在栈内存中开辟一块空间并指向对应地址值
1.在栈内存中开辟一块空间，存放引用数据类型Phone类型的变量p
2.在堆内存中开辟一块空间，存放Phone类型的对象
3.要给这个对象进行初始化，比如String brand = null;
4.当对象准备好以后，会生成一个唯一的地址值，然后将此地址值交给引用数据类型的变量p来保存
5.如果以后想要操作此对象的各种资源，可以通过p变量保存的地址值找到该对象，比如p.call(); p.price=5.22;

已Phone p =new Phone()；为例
new Phone()；为匿名对象，在在堆中
Phone p ；对象名为怕，在栈中

一个java文件中只有一个公共类

属性封装的步骤：

1.使用private封装属性
2.提供被封装属性对应的方法
getXXX()–获取属性值
setXXX()–修改属性值
方法封装的步骤：
1.使用private封装方法
2.可以在本类的公共方法里调用这个私有方法分功能

构造函数/构造方法

1.没有返回值，与本类类同名的
2.作用：用于创建对象
3.执行时机：每次创建对象都会执行构造方法
4.1无参构造：默认存在。但是一旦提供了其他的构造方法
默认的无参构造会被覆盖，所以需要手动提供
4.2含参构造：带有参数的构造方法
4.3全参构造：带有本类中所以的参数;

构造代码块

局部代码块

This

1..当本类的成员变量与局部同名时，使用this.成员变量名指定成员变量
2.this();–调用本类的无参构造
this(参数);–调用本类的有参构造
注意：必须写在第一行
不能来回调用，是单向的（不然会造成递归死循环）

继承

继承的好处
提高了代码的复用性（多个类相同的成员可以放在同一个类中）
提高了代码的维护性（如果方法的代码需要修改，只修改一处即可）
继承的坏处
继承让类与类建立了关系，类的耦合性增强
当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性

关键字Final

关键字static

静态方法是随着类的加载而加载的，普通方法是通过类的实例化加载的

而类先与对象加载，则必然静态资源不能调用普通资源（类加载的时候对象还没有被创建）

多态

多态是面向对象程序设计（OOP）的一个重要特征，

指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。（屏蔽子类对象之间的差异，把不同的子类对象都当作父类来看）

异常

异常层次结构中的根是Throwable
Error：目前我们编码解决不了的问题
Exception:异常
编译异常：未运行代码就错了，强制要求处理
运行时异常：运行代码才错，可以通过编译，不强制要求处理

抽象

Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.
Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类

如果一个类含有抽象方法,那么它一定是抽象类
抽象类中的方法实现交给子类来完成
/**抽象类不可以实例化！！！–创建对象*/

抽象
1.被Astract修饰的方法是抽象方法，抽象方法没有方法体
2.一旦一个类中包含抽象方法，这个类必须被声明为抽象类
3.如果子类继承抽象父类，有两只解决方案
1）抽象子类躺平，实现一部分/不实现父类中的抽象方法
2）普通子类，还债，实现抽象类中的所有抽象方法
4.抽象类不可以被实例化
5抽象类中是有构造函数父只不过不是为了自己使用，而是为了子类创建对象时使用
6.抽象类中可以定义成员变量成员常量
7.抽象类中的方法可以全普/全抽/半普半抽
8.如果一个类不想被实例化，那么这个类可以被声明成抽象类
9.abstract关键字不可以与private static final公用

抽象：
从理解：对外提供统一的入口

接口

与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.

接口的特点

通过interface关键字来定义接口
通过implements让子类来实现接口
接口中的方法全部都是抽象方法(JAVA8)
可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
接口突破了java单继承的局限性
接口和类之间可以多实现,接口与接口之间可以多继承
接口是对外暴露的规则,是一套开发规范
接口提高了程序的功能拓展,降低了耦合性

接口的特点
1.我们使用interface关键字定义接口
2.我们使用implements关键字建立接口实现类与接口的实现
接口是父级。接口实现类是子类
3.接口实现类需要实现接口的所有抽象方法，才能变成一个普通子类
4.接口不能实例化
5.接口没有构造函数，实现类使用的super（）是父类的无参构造
如果没有明确指定父类，super()代表的是Object的无参构造
6.接口中都是抽象方法，会默认拼接public abstract
接口中都是常量，会默认拼接public static final
8.接口不是类
9.接口是用来指定规则的：有哪些功能法有参数吗返回只值吗br> 具体实现交给接口的实现类来完成

总结:接口里是没有构造方法的

如果一个类没有明确指定它的父类，那么它默认继承顶级父类Object，调用的super()是Object的无参构造

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final

接口里的方法，默认都是抽象的，方法上会默认拼接public abstract。例如：public abstract void save();

面试解答题
类与接口的关系
1.类与类的关系
继承关系，只支持单继承
比如A是父类，B是子类，B具备A的所有功能
如果B对A的功能不满意，可以重写（两同两下）

2.类与接口的关系
实现关系，可以单实现也可以多实现
class A implements B,C{}
A是实现类，B和C是接口,A需要实现BC接口的所有抽象方法，否则A就是一个抽象类、

3.接口与接口的关系
继承关系可以单继承也可以多继承
interface A extends B,C{}
A B C 都是接口，A是子接口，具有B C父接口的所有功能（抽象方法）
class X implements A{}
X实现类需要实现A接口，以及A接口继承自B C接口的所有抽象方法，否则就是抽象类

class O extends A implemets B,C{}
其中O是实现类，也是A的子类同时拥有A的所有功能，并且需要实现BC的所有功能

接口与抽象类的区别
1.接口是用 interface定义的类型
抽象类是用class定义的类型
2.接口中的方法都是抽象方法
抽象类中的方法不做限制
3.接口当中都是静态变量
抽象类中可以写普通的成员变量
4.接口中没有构造方法，不可以实例化
抽象类中有构造方法，但是也不可以实例化
5.接口是先天设计的结果，抽象是后天重构的结果
6.接口可以多继承，抽象类只能单继承

内部类

如果一个类存在的意义就是为指定的另一个类，可以把这个类放入另一个类的内部。
就是把类定义在类的内部的情况就可以形成内部类的形式。
A类中又定义了B类，B类就是内部类,B类可以当做A类的一个成员看待:

特点：

1) 内部类可以直接访问外部类中的成员，包括私有成员

2) 外部类要访问内部类的成员，必须要建立内部类的对象

3) 在成员位置的内部类是成员内部类

4) 在局部位置的内部类是局部内部类

总结1:

1.成员内部类被Private修饰以后,无法被外界直接创建创建对象使用

所以可以创建外部类对象,通过外部类对象间接访问内部类的资源

2.静态资源访问时不需要创建对象,可以通过类名直接访问

访问静态类中的静态资源可以通过”. . . ”链式加载的方式访问

3.匿名内部类属于局部内部类,而且是没有名字的局部内部类,通常和匿名对象一起使用




public class TestInner5 {
    public static void main(String[] args) {
        //3.创建了接口1对应的匿名对象，实现了接口中的方法，调用了实现的方法

        new Inter1() {
            @Override

            public void save() {
 System.out.println("保存");
            }
 
            @Override

            public void get() {
 
            }
        }.save();
        new Inter2() {
            @Override

            public void drink() {
 System.out.println("一人饮酒醉");
            }
        }.play();
        new Inter3().study();
    }
}
 
//创建接口

interface Inter1{
    void save();
    void get();
}
 
//创建抽象类

abstract class Inter2{
    public void play(){


                                                        声明：本站部分文章及图片源自用户投稿，如本站任何资料有侵权请您尽早请联系jinwei@zod.com.cn进行处理,非常感谢！