JavaSE笔记

1.数据类型：

  • 基本类型
    • 数值类型：整数类型byte short int long、浮点数类型：float double、字符类型：char
    • boolean类型
  • 引用类型：类、接口、数组
    • String不是关键字，是类

变量：类变量、实例变量、局部变量

public class Variable{
	static int allClicks=0; //类变量
	String str="hello world"; //实例变量

	public void method(){
		int i=0; //局部变量
	}
}

常量

final 数据类型 常量名=值;
final double PI=3.14;

2.位运算

左移：<< 相当于*2

右移：>>相当于/2

3.输入

包：java.util.Scanner

基本语法：Scanner s=new Scanner(System.in)

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前一般需要使用hasNext()与hasNextLine()判断是否还有输入数据。

关闭：s.close()

区别：next():输入有效字符后，后面的空格为结束符或分隔符

       nextLine():以Enter为结束符，可以获得空白
public class Demo03{
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入数据：");
		String str=scanner.nextLine();
		System.out.println("输出内容为:"+str);
		scanner.close();
	}
}

4.值传递和引用传递：java是值传递

  • 值传递：创建副本，函数无法改变原始对象
  • 引用传递：不创建副本，函数可以改变原始对象

java都是“值传递”，关键看这个值是什么，简单变量就是复制了具体值，引用变量就是复制了地址呗。字符串是不可变的，不会被修改。

5.方法的重载

重载就是再一个类中，有相同的函数名称，但形参不同的函数。

方法的重载的规则：

  • 方法名称必须相同。
  • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
  • 方法的返回类型可以相同也可以不同。
  • 仅仅返回类型不同不足以成为方法的重载。

6.可变参数

在方法声明中，再指定参数类型后加一个省略号(...)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数必须在它之前声明。

public static void printMax(double... numbers){
	if (numbers.length == 0){
		System.out.println("No argument passed");
		return;
	}
	double result=numbers[0];

	//排序
	for (int i=1;i<numbers.length;i++){
		if (numbers[i]>result){
			result=numbers[i];
		}
	}
	System.out.println("The max value is" + result);
}

7.递归

递归结构包含两个部分：

  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
  • 递归体：什么时候需要调用自身方法。

8.数组

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同，但不是首选方法

java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组元素通过索引访问，数组索引从0开始。

获取数组长度：

array.length;

例：

public static void main(String[] args){
	int[] nums; //1.声明一个数组
	nums = new int[10]; //2.创建一个数组

//or
	int[] nums = new int[10]; //声明并创建一个数组
}

对于多维数组，其维度为：

int[][] arrays = new int[4][2];

a1 = arrays.length; //a1=4；
a2 = arrays[0].length; //a2=2；

java内存：

  • 堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用。
  • 栈：存放基本变量类型（会包含这个基本类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）

三种初始化：

  • 静态初始化：创建+赋值
int[] a = {1,2,3};
  • 动态初始化：包含默认初始化
int[] a=new int[2]; //默认初始化为0
a[0]=1;
a[1]=2;

数组的四个基本特点：

  • 其长度是确定的，数组一旦被创建，它的大小就不可以改变。
  • 其元素必须是相同类型，不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

冒泡排序：

public static void sort(int[] array){
	//临时变量
	int temp = 0;
	//外层循环，判断要走多少次；
	for (int i = 0; i < array.length-1; i++){
		//内层循环，比较两个数，如果第一个数比第二个数大，则交换位置
		for (int j = 0; j < array.length-1-i; j++){
			if (array[j+1]>array[j]){
				temp = array[j];
				array[j] = array[j+1];
        array[j+1] = temp;
			}
		}
	}
}

稀疏数组：

Untitled

9.面向对象（Object-Oriented Programming, OOP）

本质：以类的方式组织代码，以对象的形式封装数据

三大特性：封装、继承、多态

10.方法调用

  • 静态方法：
//类名.方法名()
Student.say();
  • 非静态方法：
//对象类型 对象名=对象值;
Student student=new Student();
student.say();

静态方法不能调用非静态方法：因为静态方法和类一起加载，而非静态方法是在类实例化以后才存在。

11.类与对象

  • 类：是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体事物。
  • 对象：是抽象概念的具体实例。

使用new关键字创建对象

//类：抽象的，实例化
//类实例化后会返回一个自己的对象！
//student对象就是一个Student类的具体实例
Student student = new Student();

构造器：

  • 和类名相同
  • 没有返回值

作用：

  • new本质在调用构造函数
  • 初始化对象的值

注意点

  • 定义有参构造之后，如果想使用无参构造，必须显式定义一个无参的构造
public class Person{
	//一个类即使什么都不写，它也会存在一个方法
	//显式的定义构造器

	String name;
	
	//实例化初始值
	//1.使用new关键字，本质是在调用构造器
	public Person(){} //构造器和类名相同
	
	//有参构造：一旦定义了有参构造，无参构造就必须显式定义
	public Person(String name){
		this.name = name;	
	}
}

12.创建对象内存分析

堆中存放new的数组和对象

栈中存放基本数据类型

Untitled

13.封装

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用

属性私有，get/set

public class Student{
	//属性私有
	private String name;
	private int id;
	private char sex;

	//提供一些可以操作这个属性的方法！
	//提供一些public的 get、set方法

	//get 获得这个数据
	public String getName(){
		return this.name;
	}
	
	//set 给这个参数设置值
	public void setName(String name){
		this.name = name;
	}
}

14.继承

关键字：extends

Java中只有单继承，没有多继承。“一个儿子只能有一个爸爸，一个爸爸可以有多个儿子”

//Person 人：父类
public class Person{
	//public 子类可以继承
  //private 子类无法继承
	public int money=100000;
	public void say(){
		System.out.println("说了一句话");
	}
}
----------------------------------------------------
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{}

//老师 is 人
public class Teacher extends Person{}

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

在Java中，所有的类，都默认直接或间接继承Object类。

super 和 this：

//Person 人：父类
public class Person{
	public Person(){
		System.out.println("Person");
	}
	
	protected String name = "aaa";
	
	public void print(){
		System.out.println("Person");
	}
}
--------------------------------------------------------------
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类全部方法
public class Student extends Person{
	public Person(){
		//创建子类对象时，会先执行父类构造函数，再执行子类构造函数
		//隐藏代码: super(); //调用父类的构造器必须要在子类构造器的第一行
		System.out.println("Student");
	}
	
	private String name = "bbb";

	public void print(){
		System.out.println("Student");
	}

	public void test1(){
		print(); //调用当前类Student的print()函数
		this.print(); //调用当前类Student的print()函数
		super.print(); //调用父类Person的print()函数
	}
	
	public void test(String name){
		System.out.println(name); //输出传入的参数
		System.out.println(this.name); //输出当前类Student的name值bbb
		System.out.println(super.name); //输出父类Person的name值aaa
	}
}

super注意点：

  • super调用父类的构造方法，必须在构造方法的第一个。
  • super必须只能出现在子类的方法或构造方法中。
  • super和this不能同时调用构造方法。

super vs this：

  • 代表对象不同：this代表本身调用者这个对象；super代表父类对象的引用。
  • 前提：this在没有继承也能使用；super只能在继承条件下使用。
  • 构造方法：this()调用本类构造方法；super()调用父类构造。

方法的重写：

//重写都是方法的重写，与属性无关
public class B{
	public static void test(){
		System.out.println("B=>test()");
	}
}

--------------------------------------
public class A extends B{
	public static void test(){
		System.out.println("A=>test()");
	}

	}

-------------------------------------------
public class Demo{
	//静态方法和非静态方法区别很大
	public static void main(String[] args){
		//方法的调用只和左边定义的数据类型有关
		A a=new A();
		a.test(); //输出A=>test()
		
		//父类的引用指向了子类
		B b=new A();
		b.test(); //输出B=>test()
	}
}

静态方法和非静态方法区别很大：

  • 静态方法：方法的调用只和左边定义的数据类型有关
  • 非静态方法：

静态方法是类的方法（类的成员），而非静态方法是对象的方法。有static时，b调用了B类的方法，因此b使用B类定义的；没有static时，b调用的是对象的方法，而b使用A类new的，即b是A new出来的对象，因此调用了A的方法。

重写注意点：需要有继承关系，子类重写父类方法

  • 方法名必须相同
  • 参数列表必须相同
  • 修饰符：范围可以扩大 但不能缩小public>Protected>Default>private
  • 抛出的异常：范围可以缩小，但不能扩大

15.多态

public class Person{
	public void run(){
		System.out.println("run");
	}
}

------------------------------------
public class Student extends Person{
	public void run(){
		System.out.println("son");
	}

	public void eat(){
		System.out.println("eat");
	}
}

-----------------------------------------
public class Demo{
	public static void main(String[] args){
		//一个对象的实际类型是确定的
		//new Student();
		//new Person();

		//可以指向的引用类型就不确定了:父类的引用指向了子类		
		
		//Student能调用的方法都是自己的或者继承父类的！
		Student s1 = new Student();
		//Person 父类型，可以指向子类，但是不能调用子类独有的方法
		Person s2 = new Student();
		Object s3 = new Student();
	
		//对象能执行哪些方法，主要看对象左边类型，和右边关系不大！
		s2.run(); //子类重写了父类的方法，执行子类的方法
		s1.run();
	}
}

多态注意事项：

  • 多态是方法的多态，属性没有多态。
  • 有父类子类关系才能转换
  • 存在条件：1.有继承关系；2.方法需要重写；3.父类引用指向子类对象：father f1=new son();

哪些方法不能被重写：

  • 1.static方法：属于类，不属于实例
  • 2.final：常量，无法修改
  • 3.private方法

instanceof 关键字：判断一个对象是什么类型

public class Person{
	
}

------------------------------------
public class Student extends Person{
	
}

------------------------------------
public class Teacher extends Person{
	
}

-------------------------------------
public class Demo{
	public static void main(String[] args){
		
		//Object > String
		//Object > Person > Student
		//Object > Person > Teacher
		Object object = new Student();

		//System.out.println("x instanceof Y"); //能不能编译通过看它们有没有父子关系
		
		System.out.println(object instanceof Student); //true
		System.out.println(object instanceof Person); //true
		System.out.println(object instanceof Object); //true
		System.out.println(object instanceof Teacher); //false
		System.out.println(object instanceof String); //false
		System.out.println("========================");
		Person person = new Student();
		System.out.println(person instanceof Student); //true
		System.out.println(person instanceof Person); //true
		System.out.println(person instanceof Object); //true
		System.out.println(person instanceof Teacher); //false
		System.out.println(person instanceof String); //编译报错
		System.out.println("========================");
		Student student = new Student();
		System.out.println(student instanceof Student); //true
		System.out.println(student instanceof Person); //true
		System.out.println(student instanceof Object); //true
		System.out.println(student instanceof Teacher); //编译报错
		System.out.println(student instanceof String); //编译报错
	}
}

类型转换：

public class Person{
	public void go(){
		System.out.println("run");
	}
}

------------------------------------
public class Student extends Person{
	public void go(){
		System.out.println("go");
	}
}

-------------------------------------
public class Demo{
	public static void main(String[] args){
		//类型之间的转换：父 子
		
		//高                    低
		Person student = new Student();
		
		//将student对象转换为Student类型，就可以使用Student类型的方法！
		Student stu1 = (Student) student;
		stu1.go();
		//or
		((Student) student).go();

		//子类转换为父类，可能丢失自己本来的一些方法
		Student stu2 = new Student();
		Person person = student;
		person.go(); //编译报错
		
	}
}

注意点：

  • 父类引用指向子类的对象。
  • 把子类转换为父类，向上转型。
  • 把父类转换为子类，向下转型：强制转换可能丢失一些方法。
  • 方便方法的调用，减少重复的代码。

16.static关键字：

public class Student{
	
	private static int age; //静态变量 多线程
	private double score; //非静态变量

	public void run(){}

	public static void  go(){}

	public static void main(String[] args){
		
		Student s1 = new Student();

		System.out.println(Student.age);
		System.out.println(Student.score); //编译报错
		System.out.println(s1.age);
		System.out.println(s1.score);

		
	}
	
}

静态代码块：

public class Person{
	//2：赋初始值
	{
		System.out.println("匿名代码块");
	}
	
  //1最早执行,只执行一次！
	static{
		System.out.println("静态代码块");
	}

	//3
	public Person(){
		System.out.println("构造方法");
	}

	public static void main(String[] args){
		Person person1 = new Person();
		System.out.println("===========");
		Person person2 = new Person();
	}
}

输出结果：

Untitled

17.抽象类：

abstract关键字可以修饰方法也可以修饰类，如果修饰方法就是抽象方法，如果修饰类，就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类必须声明为抽象类。

//abstract 抽象类:类 extends：单继承 （接口可以多继承！）
public abstract class Action{
	
	//约束~有人帮我们实现
	//abstract，抽象方法，只有方法名字，没有方法的实现！
	public abstract void doSomething();

	//1.不能new抽象类，只能靠子类去实现它的约束！
	//2.抽象类中可以写普通方法
	//3.抽象方法必须在抽象类中
	//抽象的抽象：约束
	
}

---------------------------------------------------
//抽象类的所有方法，继承了它的子类，都必须要实现他的方法，除非该子类也是抽象类
public class A extends Action{
	public void doSomething(){
		
	}
}

18.接口：

声明类的关键字是class，声明接口的关键字是interface。

普通类：只有具体实现。

抽象类：具体实现和规范（抽象方法）都哟。

接口：只有规范

接口的本质就是契约，就像我们人间的法律一样，制定好后大家都遵守。

//定义关键字 interface,接口都要有实现类
public interface UserService{
	//接口中所有定义的属性都是常量 public static final
	int age = 99;
		//接口中的所有定义的方法其实都是抽象的 public abstract
	void add(String name);
	void delete(String name);
	void update(String name);
	void query(String name);
}

----------------------------------------------
public interface TimeService{
	void timer();

}

-----------------------------------------
//抽象类：extends 单继承
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法

//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
	public void add(String name){}
	public void delete(String name){}
	public void update(String name){}
	public void query(String name){}

	public void timer(){}

}

接口的作用：

  • 约束。
  • 定义一些方法，让不同的人实现。
  • 方法都是public abstract ； 常量都是public static final。
  • 接口不能被实例化，接口中没有构造方法。
  • implements可以实现多个接口。
  • 必须要重写接口中的方法。

19.内部类：

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

public class Outer{
	
	private int id=10;
	public void out(){
		System.out.println("这是外部类的方法");
	}

	public class Inner{
		public void in(){
			System.out.println("这是内部类的方法");
		}

		//获得外部类的私有属性、私有方法
		public void getID(){
			System.out.println(id);
		}
	}

	//局部内部类:在方法中定义类
		public void method(){
			class Inner{
				public void in(){}
			}
		}
	
}

---------------------------------
public class Demo{
	public static void main(String[] args){
		//new
		Outer outer = new Outer();

		//通过外部类实例化内部类
		Outer.Inner inner = outer.new Inner();
	  
	}
}
public class Test{
	public static void main(String[] args){
		//没有名字初始化类，不用将实例保存到变量中
		new Apple().eat;
	}
}

class Apple{
	public void eat(){
		System.out.println("1");
	}
}

20.异常：

Untitled

异常体系结构

/**
* java.lang.Throwable
*      |-----java.lang.Error:一般不编写针对性的代码进行处理
*      |-----java.lang.Exception:可以进行异常的处理
*          |-----编译时异常（checked）
*              |-----IOException
*                  |-----FileNotFoundException
*              |-----ClassNotFoundException
*          |-----运行时异常（unchecked）
*              |-----NUllPoointerException
*              |-----ArrayIndexOutOfBoundsException
*              |-----ClassCastException
*              |-----NumberFormatException
*              |-----InputMismatchException
*              |-----ArithmeticExcetion
*
*
*
*/

异常处理机制：

抛出异常

捕获异常

异常处理五个关键字：try、catch、finally、throw、throws

public class Test{
	public static void main(String[] args){
		int a = 1;
		int b = 0;

		//假设要捕获多个异常，范围要从小到大
		try { //try监控区域

			if (b==0){//主动抛出异常 throw throws
				throw new ArithmeticException();
			}
			
			System.out.println(a/b);
		}catch (ArithmeticException e){ //catch(想要捕获的异常类型) 捕获异常
			System.out.println("程序出现异常，变量b不能为0");
		}catch (...){
		}
		catch (...){
		}
		finally{ //处理善后工作，一定会执行 非必需
			System.out.println("fianlly");
		}
		
		//finally可以不要，假设IO、资源关闭需要finally
	}

	//假设这个方法中处理不了这个异常，在方法上抛出异常
	public void test(int a, int b) throws ArithmeticException{
		if (b==0){//主动抛出异常 throw throws
				throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
			}
			
			System.out.println(a/b);
	}
}

自定义异常：

//自定义异常类
public class MyException extends Exception{	

}
posted @ 2022-11-28 17:35  柯文先生  阅读(30)  评论(0)    收藏  举报