JAVA显示子类num值_《Java核心技术I》笔记

仅仅是边读边记的笔记，因为不像是某些资料，这本书并不是成“体系”的，比较“混乱”，所以，索性都记录到一个md文件里咯(看的比较随意，除了第一第二章外，有些难的或者偏也都直接跳过了😜，看第二遍的时候再补回来吧 maybe。。。)

第 3 章 Java的基本程序设计结构

1.第一个程序

public class Hello {

public static void main(String[] args) {

System.out.println("Hello World");

}

}public(访问修饰符) 用于控制对所修饰的类或对象或字段的访问级别

class表示这是一个类，Hello则是这个类的类名

main方法是所有程序的入口

大括号表示方法体的开始与结束

2.注释

//单行注释

/*多行注释，(不能嵌套使用)*/

/*** 文档注释* 可用于自动的生成文档*/

3.数据类型

基本类型

位数

字节

默认值

int

32

4

0

short

16

2

0

long

64

8

0L

byte

8

1

0

char

16

2

‘u0000’

float

32

4

0f

double

64

8

0d

boolean

1

false

4.变量与常量

变量

声明变量

int a;

String name;

即 以变量类型 变量名这种形式来声明一个变量

变量初始化

声明一个变量后，必须用赋值语句对变量进行显式初始化，如下

int a = 0;

String name = "任我行";

常量

常量就是值不会变的变量

可用final关键字来修饰常量，而且通常此常量名为大写

public final String BAIDU_URL = "www.baidu.com";

枚举类型

作用：限制变量的取值范围

如下：

enum Size {SMALL,MEDIUM,LARGE,EXTRA_LARGE};

那么Size类型的变量只能取里边的值

5.运算符

算术运算符

算术运算符

表示

+

加

-

减

*

乘

/

除

%

取模

类型转换

如参与运算的两个数类型不一致，则结果为较大类型的整型

强制转换：(有可能损失信息)

其他运算符

二元运算符：例如x+=4;，运算符放于等号左边

自增自减运算符

++x 前缀形式会先加1再使用

x++ 后缀形式会先使用原来的值，之后才加1

关系运算符：如==,!=，>=之类的，还有&&和||

三元运算符：x>0 ? true : false如表达式为真，则为true，如假则为false

短路(&&和||运算符的逻辑)：如果第一个操作数已经能够确定表达式的值，第二个操作数就不必再计算了

6.字符串

先跳过，待补充

7.输入与输出

Scanner input=new Scanner(System.in);

System.out.println("请输入一个数字");

int num=input.nextInt();//输入System.out.println("你输入的数字是："+num);//输出

8.控制流程

条件分支流程

普通分支语句

int a = 1;

int b = 2;

if (a > b) {

System.out.println("a大于b");//如果a大于b则执行这个语句 } else if (a == b) {

System.out.println("a等于b");//如果a等于b则执行这个语句 } else {

System.out.println("a小于b");//否则就a小于b，当以上两种情况都不是的时候执行 }

条件多分支语句

int g=2;

switch(g) {

case 1:{

System.out.println("是1");//当g是1时执行break;

}

case 2:{

System.out.println("是2");//当g是2时执行break;

}

default:{

System.out.println("都不是");//当以上情况都不是的时候执行break;

}

}

循环流程

根据条件，反复执行某些操作

for

for(int i=0;i<5;i++) {//int i=0是初始值，i<5是循环条件。i++是循环后更新i的值，然后进入下一轮循环System.out.println("循环第"+i+"次");

}while

int u=5;

while(u>0) {//当为true时执行System.out.println("u="+u);

--u;

}do..while

int p=0;

do {//无条件进入循环++p;

System.out.println("p="+p);

}while(p<5);//首先执行一次循环体后进行判断，若为true则继续进行下去for each(增强型for循环)

for ( 类型 变量名: 数组或集合 ) {

循环体

}与普通for循环的区别：for each循环语句的循环变量将会遍历数组中的每个元素，而不是下标值

9.大数

BigInteger实现任意精度的整数运算

BigDecimal实现任意精度的浮点数运算

10.数组

存储一组具有相同数据类型的数据元素的有序集合

// 声明int num[];

int[] sum;

// 静态初始化int num[]={1,2,3,4,5}

//动态初始化int num[]=new int[5];//预先分配内存空间for(int i=0;i<5;i++){

num[i]=i*3;

}

第 4 章对象与类

1.面向对象

面向对象编程，是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。

面向对象程序设计：程序由对象来组成

类：构造对象的模板或蓝图

对象：类的实例化

类和对象的关系好比 模具 和 具体的用模具实际做出来的东西

2.使用预定义类

构造器

用来构造并初始化对象的一种特殊的方法

构造器的名字应该与类名相同

这里要明确一个东西，比方说，我定义了一个类叫做Animal，然后做了如下的操作

Animal mAnimal;

此时，mAnimal叫做对象变量，它是一个变量，不是一个对象

然后做如下操作

mAnimal = new Animal();

此时mAnimal引用了一个对象

3.用户自定义类

隐式参数与显示参数

一句话，隐式参数是调用方法的对象本身(在方法中可用this来表示)，显示参数是方法名后面的数值

4.静态字段和静态方法

静态字段

静态字段即用static修饰的字段，静态字段是属于类，不属于单个任何对象的

静态方法

用static修饰的方法，属于类，不属于对象，即在静态方法中不能使用this关键字

5.方法参数

跳过

6.对象构造

重载

方法签名：方法名和参数列表描述了一个方法

重载即是出现了多个方法，有相同的名字，但是不同的参数，程序会在调用方法时根据参数类型来选择使用哪一个方法

7.包

使用包来确保类名的唯一性

静态导入

第 5 章继承

1.类，子类，超类

this和super的含义

this

一是指隐式参数的调用

二是指调用该类的其他构造器

super

一是调用超类的方法

二 是调用超类的构造器

Java中4种访问修饰符

private：仅对本类可见

public：对外部完全可见

protected：对本包及所有子类可见

默认(无需修饰符)：对本包可见

多态

一个对象变量可以指示多种实际类型的现象称为多态

替换原则：程序中出现超类对象的任何地方都可以使用子类对象替换。例如：可将子类对象赋给超类变量

重载解析：。。。

动态绑定与静态绑定：

动态绑定：在运行时能够自动地选择恰当的方法(调用的方法依赖隐式参数的实际类型)

静态绑定：用private，static，final修饰的方法，编译器将准确的知道该调用哪个方法

强制类型转换

唯一原因：要在暂时忽视对象的实际类型之后使用对象的全部功能。

可用instanceof操作符来判断所属类型

抽象类

更具有一般性的，只用作派生其他类的基类，而不是用来构造实例的类

可以包含字段和具体方法

不能被实例化

2.Object：所有类的超类

Object类是Java中所有类的氏族，每个类都自动的继承自Object类

在Java中，只有基本类型不是对象。

4.对象包装器和自动装箱拆箱

对象包装器

因为基本类型不是对象，但有时候又需要把基本类型转换成对象来使用，所以就出现了对象包装器这个概念。

基本类型

对应的包装器类

int

Integer

long

Long

float

Float

double

Double

short

Short

byte

Byte

char

Character

boolean

Boolean

包装器类是final的

自动装箱与自动拆箱

List list = new ArrayList<>();

list.add(2);

如上面给出的例子，list添加一个元素的时候，元素类型本该是Integer类型，可是2只是个int类型，不过没关系，list.add(2)将自动的变成list.add(Integer.valueOf(2))，这种变换称为自动装箱

同样的，如果想将一个Integer对象赋给一个int值时，将会自动拆箱

第 6 章接口，lambda表达式与内部类

1.接口

在Java程序设计语言中，接口不是类，而是对希望符合这个接口类的一组需求

接口中的所有方法都自动是public方法(但是实现接口时，必须把方法声明为public)

接口中的字段总是public static final的

接口绝不会有实例字段

接口同样不能被实例化，但是接口变量可以引用实现了这个接口的类对象

一个类只能有一个超类，但可以实现多个接口

2.lambda表达式

先跳过，看的云里雾里的@_@

3.内部类

定义在另一个类中的类

原因：

内部类可以对同一包中的其他类隐藏

内部类方法可以访问外部类的私有属性

常规内部类中可以有static字段(但也都必须是final)，但是不能有static方法

局部内部类

在一个方法中局部地定义这个类

声明局部类时不能有访问说明符(public等)

对外界完全隐藏

静态内部类

内部类不需要访问外围类对象，就应该使用静态内部类

静态内部类可以有静态字段和静态方法

在接口中声明的内部类自动是static和public

第 7 章异常，断言和日志

派生于Error类或RuntimeException类的所有异常称为非检查型异常

所有其他异常称为检查型异常

这一章的剩余部分先略过，先不看

第 8 章泛型程序设计

泛型方法：可以在普通类型中定义，也可在泛型类中定义

public class ArrayAlg {

public static T getMiddle(T... a) {

return a[a.length / 2];

}

}

限定类型： 限定T只能是限定类型的子类型

//甚至是多个限定

类型擦除：指的是定义了一个泛型类型，都会自动提供一个相应的原始类型。(原始类型用第一个限定来替换类型变量，如无限定，则替换为Object类型)

通配符(?)：

extends Employee> //表示参数类型是Employee的子类 super Employee> //表示参数类型是Employee的超类

第 12 章并发

多线程：一个程序可以同时运行多个线程

多进程和多线程的区别：每个进程都拥有自己的一整套变量，而线程则共享数据

新建线程的两种方式

一：新建类实现Runnable接口(完成run方法)，然后赋给一个Thread对象

public static class MyRun implements Runnable {

@Override

public void run() {

System.out.println("MyRun");

}

}

// 使用 Runnable r = new MyRun();

Thread thread1 = new Thread(r);

thread1.start();

二：建立一个Thread的子类

public static class MyThread extends Thread {

@Override

public void run() {

super.run();

System.out.println("MyThread");

}

}

// 使用 Thread thread2 = new MyThread();

thread2.start();

线程的状态

New：新建

Runnable：可运行(可能正在运行也可能没有运行)

Blocked：阻塞

Waiting：等待

Timed waiting：计时等待

Terminated：终止

synchronized关键字

从Java1.0版开始，Java中的每个对象都有一个内部锁。如果一个方法声明时有 synchronized 关键字，那么，要调用这个方法，线程必须获得内部对象锁

volatile修饰符：用来修饰字段，可以让多线程安全地读取一个字段