JAVA韩顺平 学习笔记（重点部分摘抄）
转义字符
1. \t : 一个制表位,实现对齐的功能
2. \n : 换行符
3. \\ : 一个\
4. \" : 一个"(双引号)
5. \' : 一个'(单引号)
6. \r : 一个回车
多行注释
/*
注释的内容
*/
使用细节
- 多行注释里面不允许有多行注释嵌套,不能嵌套
- 注释内容不会被运行
单行注释
// 注释的内容
JavaDoc注释规范的内容
1）类级别的注释
在类级别的注释中，需要说明类的用途、实现方式、注意事项等。示例：
/**
* This class represents a person, with a name and an age.
*
* Instances of this class can be compared using the compareTo method, which compares their ages.
*
* Note that the name cannot be modified once set.
*/
public class Person implements Comparable<Person> {
...
}
在上面的示例中，注释说明了这个类的作用，可以做到什么事情，同时也说明了这个类的限制。
2） 方法级别的注释
在方法级别的注释中，需要说明方法的作用、输入参数、输出结果、实现原理等。示例：
/**
* Returns the n-th Fibonacci number.
*
* @param n the index of the Fibonacci number to return.
* @return the n-th Fibonacci number.
*/
public static int fibonacci(int n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n-1) + fibonacci(n-2);
}
}
在上面的示例中，注释说明了这个方法的作用，需要传入什么参数，返回什么结果以及方法的实现原理。
3） 变量级别的注释
在变量级别的注释中，需要说明变量的作用、类型、取值范围等。示例：
/**
* The name of this person.
*/
private final String name;
/**
* The age of this person.
*/
private int age;
在上面的示例中，注释说明了这两个变量的作用以及类型。
4）结论
JavaDoc注释规范是Java程序开发中不可或缺的一部分，遵循注释规范可以提高代码的可读性、方便文档编写、便于代码审查等，从而提高代码的质量和效率。
DOS原理（磁盘操作系统）
换盘 要有 \ (反斜杠)
cls 清屏
相对路径&绝对路径
加号+的使用
- 运算顺序从左到右
整型细节
-
整数默认int类型
-
声明long型数值后面必须加‘L’或者‘l’
例如：
long a=5L；
浮点型细节
-
java的浮点型常量(具体值)默认为double类型
-
声明float型数值后面必须加‘F’或者‘f’
例如
float x=0.01f; //对
float k=0.01; //×错误,0.01是double类型,会损失精度 赋值类型冲突
double b=0.1F; //对
double b=.1; //对,这是省略写法
-
不确定未来浮点数的变量的精度,直接使用double
-
浮点数使用陷阱:不能判断相等
double num1=2.7;
double num2=8.1/3; //2.7
System.out.println(num1);
System.out.println(num2); //接近2.7的一个小数,而不是2.7
所以
if(num1==num2)
System.out.println(""相等"");
不会输出相等,因为num1不会等于num2
应该是num1-num2的绝对值不超过某个范围,使用java API
if(Math.abs(num1-num2)<0.000001)
System.out.println(""相等"");
java文档
网站地址:java文档
在java文档里面可以找到java提供的API
自动类型转换细节(只有占用空间从小—>大)
- (byte char)和short之间不会相互自动转换.例如:
byte a =10;
char B=a; //错
byte B1 = 10; //对,直接赋值整数可以
-
byte char short 三者可以计算,在计算时首先转换成int类型,但是最后是int类型 不能赋值给byte char short
-
boolean不参与类型转换
boolean pass = true;
int a = paas; //错误
强制类型转换:空间从大—>小 (int)(float)
int i = (int)1.77777; //强制把小数转换为整数
标识符命名规范
- 大驼峰 ：类名，接口名
public class StuName；
- 小驼峰 ：变量名
string stuName；
用户的输入 类Scanner 包java.util.*
import java.util.Scanner;
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in); //创建Scanner类的对象
System.out.println("请输入名字");
String name = scanner.next(); //获取输入的信息存入name
System.out.println("请输入年龄");
String age = scanner.next(); //获取输入的信息存入age
}
数组
1）一维数组的定义
//等价
int[] number = {}; //方式1 定义int类型的数组,变量名number,静态初始化
int number[] = {}; //方式2
//等价
int number[] = new int[6]; //1.分配空间给数组,动态初始化
int[] number = new int[6]; //2.分配空间给数组
- 数组名的长度：数组名.length
2)二维数组的定义
int Num[][] = {{1,2},{3,4,5},{8,8,8,8}}; //静态初始化,每一行的元素 数量可以不同
//等价的三种方式
int Num[][] = new int[5][6]; //1.动态初始化初始化二维数组(我的习惯用法)
int[][] Num = new int[5][6]; //2.
int[] Num[] = new int[5][6]; //3.
类与对象
对象内存的布局
基本数据类型直接存储在堆，String等引用类型存放“指针”在堆（C语言的指针概念，java没有指针），该指针指向方法区的数据内容。
方法传参机制
韩顺平java—P213 讲的很详细。
方法重载
java中允许同一个类中，多个同名的方法存在，但是形参列表不一致。
class Student{
int addNum(int a,int b){
return a+b;
}
int addNum(int a,int b,int c){ //重载
return a+b+c;
}
}
- 典型的System.out.println()
可变参数
class Jisuan{ //类
caculate(int... nums){ //可变参数,sums相当于数组接收多个int型数据
int sum=0;
for(i=0;i<nums.length;i++){
sum+=nums[i];
}
return sum;
}
}
public static void main(String[] args) {
Jisuan k=new Jisuan();
int sum=k.caculate(1,7,5,80);
System.out.println("sum="+sum);
}
可变参数使用细节(重点在4)
- 5)解释:只能有一个可变参数(就是…)
类中局部变量和全局变量的使用细节
-
属性和局部变量可以同名，访问时采用就近原则
-
两个局部变量不能重名
-
初值不同
局部变量无默认初值，必须赋初值
全局变量有默认初值
- 修饰符不同
全局变量/属性 可以加修饰符
局部变量不可以加修饰符
构造器/构造方法
- 介绍
构造器使用细节(快捷键alt+insert)
重点在7
class Cat(){
//默认gou
Cat(){
}
}
包原理
包的命名规范
常用的包
包的使用细节
- 建议用到包里面的哪个类就具体导入哪个类，不要全部导入。
访问修饰符
-
如果定义private int a = 10，则其他类可以调用该类的方法，利用该方法调用类去使用a变量。但是无法直接使用a变量。
-
只有 默认 和 public 可以修饰 类
面向对象编程的三大特征（封装、继承、和多态）
封装（encapsulation）
封装就是把抽象出的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作【方法】，才能对数据进行访问。（调用方法修改属性）
对电视机的操作就是典型封装。
如果p.age = 1200;那么没有人可以活1200年,此时就需要对属性修改通过方法进行验证.
public Cat(String name, int age, String color) {
setName(name);
setAge(age);
setColor(color);
}
可以防止通过构造器设置不符合的属性
继承
-
在创建子类的对象时,同时也必定会调用父类的无参构造器(顺序:父类先,子类后)
-
子类的构造器会自动有下面一行代码
super();
- 如果父类没有定义无参构造器就必须得使用父类别的构造器来完成父类初始化工作(定义了新的构造器,原来默认的无参构造器会消失)
方法重写（override）
多态
养宠物引出多态
动物越多导致feed方法就越多,不利于维护
方法的多态
利用重载写出同名方法的不同形态，调用时根据参数列表使用对应形态的方法。
public int sum(int a,int b);
public int sum(int a,double b,int c);
对象的多态(核心)
- 父类可以接收子类的信息 父=new 子;
Animal animal = new Dog(); //左边编译类型是Animal父类,右边运行类型是Dog子类(左右可以不一致)
animal = new Cat();
- 前提是 两个对象(类)存在继承关系
多态向上转型
-
可以调用父类的方法(需要遵守访问权限),但是不能调用子类特有的成员(此时看编译类型,是父类).
-
在调用方法时,先按照从子类开始查找方法,子类没有,就找父类.
总之不能是子类单独定义的新变量或者新方法(独特),重载也不可以(相当于新方法),重写可以(参数列表一致)
多态向下转型(强转)(前提是3)
类似于(int)3.1415926
Animal animal = new Cat();
Cat cat=(Cat)animal; //新对象cat指向原来animal指向的对象,这时新对象cat可以调用cat的特有成 //员
解释图如下:
属性重写问题
public class Test {
public static void main(String[] args) {
Animal animal = new Fish();
System.out.println("age = "+animal.age); //10 根据编译类型（左边）确定
}
}
class Animal { //父类
int age = 10;
}
class Fish extends Animal{ //子类
int age = 20;
}
- 属性看编译类型看，属性 没有重写。
instanceOf 比较操作符
- 用于判断对象的运行类型是否为XX类或者XX类的*子类,*返回true或者false
Animal animal =new Animal();
System.out.println(animal instanceof Animal); //true
java的动态绑定机制(重要)
1.当调用对象方法的时候,该方法会和该对象的 内存地址/运行类型 绑定
2.当调用对象属性时,没有动态绑定机制
public class Test {
public static void main(String[] args) {
Animal animal = new Fish();
System.out.println(animal.sum()); //20+10=30
}
}
class Animal { //父类
int age = 10;
int sum(){
return getAge() + age;
}
public int getAge(){
return age;
}
}
class Fish extends Animal{ //子类
int age = 20;
public int getAge() {
return age;
}
}
animal.sum(),子类没有sum()方法,然后去调用父类的sum().
父类调用getAge() ,此时父类和子类都有该方法,根据动态绑定,调用子类的getAge()
多态的应用
多态数组
数组的定义类型为父类类型,但是里面保存的实际元素类型为子类类型
- 调用数组元素的特有方法(判断->向下转型)
1031
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
