java韩顺平学习笔记

likeOOK

已于 2022-08-30 23:19:09 修改

阅读量984

点赞数

文章标签：学习 java

于 2022-08-30 21:37:43 首次发布

本文链接：https://blog.csdn.net/yuanzic1/article/details/126566331

版权

此学习笔记为本人学习中所记录的内容，不代表任何人！笔记内容远远少于老师视频内容！

0236 作用域基本使用

全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。

0237 作用域使用细节1

1.属性和局部变量可以重名，访问时遵循就近原则。

0238 作用域使用细节2

属性可以加修饰符(public protected private)

局部变量不能加修饰符

0239 构造器基本介绍constructor

1.构造器的修饰符可以默认，也可以是public protected private

2.构造器没有返回值

3方法名和类名必须一样

4.构造器的调用由系统完成

0242 构造器使用细节2

javap指令反编译例：javap Dog.class

一旦定义了自己的构造器，默认的构造器就覆盖了，就不能使用默认的无参构造器，除非显式的定义一下。

0244 对象创建流程详解

class Person{
	int age = 90;
	String name;
	Person(String n, int a){
		name = n;
		age = a;
	}
}
Person p = new Person("q", 20);

流程分析：

1.加载Person类信息(Person.class)，只会加载一次

2.在堆中分配空间（地址）

3.完成对象初始化（1.默认初始化age = 0 name = null 2.显式初始化age = 90 name = null 3.构造器的初始化 age = 20 name = q）

4.在对象在堆中的地址，返回给p（p是对象名，也可以理解成是对象的引用）

0249 this使用细节

访问构造器语法：this(参数列表); 注意只能在构造器中使用（即只能在构造器中访问另外一个构造器）如果有this访问构造器的语法，必须放在第一条语句 复用构造器

0251 本章作业01

对象可以为空： Person p = null;

0255 本章作业05

pi：Math.PI

0257 本章作业07

public class Test{
	int count = 9;
	public void count1(){
		count = 10;
		System.out.println("count1=" + count);
	}
	public void count2(){
		System.out.println("count1=" + count++);
	}
	public static void main(String[] args) {
		new Test().count1();
		Test t1 = new Test();
		t1.count2();
		t1.count2();
	}
}

1.任何一个类，都可以有main

2.new Test()是匿名对象，匿名对象使用后，就不能使用

0260 本章作业10

动态修改this的属性值用setXxx()

0261 本章作业11

[0,n)的随机数：

import java.util.Random;
Random random = new Random();
random.nextInt(3);    //0 1 2

自己写的（猜拳）

import java.util.Random;
import java.util.Scanner;
public class Homework14{
	public static void main(String[] args) {
		Random random = new Random();
		Scanner myScanner = new Scanner(System.in);
		int win = 0;
		int lose = 0;
		while(true){
			System.out.println("==================");
			int machine = random.nextInt(3);
			int Tom = myScanner.nextInt();
			if(Tom == 0 || Tom == 1 || Tom == 2){
				System.out.println("machine=" + machine);
				System.out.println("Tom=" + Tom);

				T t1 = new T(machine, Tom);
				int res = t1.check();
				
				if(res == 1){
					win++;
					System.out.println("win " + win + " times");
				} else if(res == 2){
					lose++;
					System.out.println("lose " + lose + " times");
				}
			} else{
				System.out.println("please reinput...");
			}
		}
	}
}
class T{
	int machine;
	int Tom;

	public T(int machine, int Tom){
		this.machine = machine;
		this.Tom = Tom;
	}
	public int check(){
		if(Tom - machine == 0){
			System.out.println("even");
			return 0;
		} else if(Tom - machine == 2 || Tom - machine == -1){
			System.out.println("win");
			return 1;
		} else if(Tom - machine == 1 || Tom - machine == -2){
			System.out.println("lose");
			
			return 2;
		}
		return 0;
	}
}

0270 IDEA快捷键3

ctrl+Y 删除一行

ctrl+D 复制一行

alt+insert 构造器

ctrl+h 查看类的继承关系 ->右键选diagrams查看图

类后加.var 自动分配变量名

0271 IDEA模板

main sout fori

file->settings->editor->Live templates

0275 包命名

com.公司名.项目名.业务模块名

0276 常用的包

java.lang.* lang包的类默认引用

java.util.*

java.net.*

java.awt.*

0277 包的使用细节

Arrays.sort(arr); 排序

package需要放在最上面，一个类最多只有一句package

import指令在package下面，在类定义之前

0278 访问修饰符规则

访问级别	访问控制修饰符	同类	同包	子类	不同包
公开	public	√	√	√	√
受保护	protected	√	√	√	×
默认	没有修饰符	√	√	×	×
私有	private	√	×	×	×

1.在同一类中，可以访问public protected 默认 private修饰

2.在同一个包中，可以访问public protected 默认修饰

3.在不同包下，可以访问public修饰

4.只有默认和public可以修饰类

0281 封装步骤

1.属性私有化

2.set方法对属性验证并赋值

3.get方法获取属性的值，权限判断

0282 封装快速入门

setXxx和getXxx在generate ->getter and setter

0283 封装与构造器

将set方法写在构造器中，仍然可以验证数据

0289 继承使用细节2

1.子类必须调用父类的构造器，完成父类的初始化，会默认调用父类的无参构造器，隐藏了super();

2.如果父类没有提供无参构造器，必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。

0290 继承使用细节3

1.如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)

2.super在使用时，必须放在构造器的第一行（super只能在构造器中使用）

3.super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

0291 继承使用细节4

java所有类都是Object类的子类，Object是所有类的基类

0292 继承使用细节5

子类最多只能继承一个父类（指直接继承），即java中是单继承机制。

Q：如何让A类继承B类和C类？

A：A继承B，B继承C

0293 继承本质详解

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        //(1)首先看子类是否有该属性
        //(2)如果子类有这个属性，并且可以访问(非private)，则返回信息
        //(3)如果子类没有这个属性，就看父类有没有这个属性（如果父类又改属性，并且可以访问，就返回信息）
        //(4)如果父类没有就按照(3)的规则，继续找上级父类，直到Object
        System.out.println(son.name);   // 大头儿子
        System.out.println(son.getAge());    //39
        System.out.println(son.hobby);  //旅游
    }
}
class GrandPa{
    String name = "大头爷爷";
    String hobby = "旅游";
}
class Father extends GrandPa{
    String name = "大头爸爸";
    private int age = 39;
    public int getAge(){
        return age;
    }
}
class Son extends Father{
    String name = "大头儿子";
}

0294 继承课堂练习1

public class ExtendsExercise01 {
    public static void main(String[] args) {
        B b = new B();

    }
}
class A{
    A(){
        System.out.println("a");
    }
    A(String name){
        System.out.println("a name");
    }
}
class B extends A{
    B(){
        //有this就不能有super
        this("abc");
        System.out.println("b");
    }
    B(String name){
        //默认super()
        System.out.println("b name");
    }
}

0299 super使用细节2

使用super访问遵循就近原则

0301 方法重写介绍

重写(override)：父类和子类的方法定义形式一样（名称，返回类型，参数）

0302 方法重写细节

1.子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样

2.子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类

例：父类返回类型是Object，子类返回类型是String

public Object getInfo() publicc String getInfo()

3.子类方法不能缩小父类方法的访问权限

0303 重写课堂练习1

名称	发生范围	方法名	形参列表	返回类型	修饰符
重载(overload)	本类	必须一样	类型，个数或顺序至少有一个不同	无要求	无要求
重写(override)	父子类	必须一样	相同	子类重写的方法。返回的类型和父类返回的类型一致，或者是其子类	子类方法不能缩小父类方法的访问范围

0304 重写课堂练习2

public String say(){
        return super.say() + " id=" + id + " score=" + score;
    }