Java 基础知识点 笔记总结

Posted IT_Holmes

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 基础知识点 笔记总结 相关的知识,希望对你有一定的参考价值。

1. static 关键字

static 静态关键字可以用来修饰:属性,方法,代码块,内部类。

1.1 static 修饰属性

静态变量,相当于共享了这个变量,这样你修改其他的实例对象的这个静态变量,全部的这个静态属性值都会跟着变。

package com.itholmes.p2;

public class StaticTest {
	public static void main(String[] args) {
		Chinese c1 = new Chinese();
		c1.name = "张三";
		c1.age = 40;
		c1.nation = "chinese";
		
		Chinese c2 = new Chinese();
		c2.name = "李四";
		c2.age = 20;
		c2.nation = "中国";
		
		//由于使用static修饰了nation,因此nation就变成了共享c2的修改,也会对c1修改!
		System.out.println(c1.nation);
	}
	
}

class Chinese{
	String name;
	int age;
	static String nation;
}

实例变量是随着类的对象的创建在堆空间中完成的。

而静态变量是随着类的加载而加载完成的。

相比较显然,静态变量要比实例变量先一步创建。

因此,我们可以从一开始不用创建对象,就可以定义静态变量的值。

package com.itholmes.p2;

public class StaticTest {
	public static void main(String[] args) {
		
		//因为,静态变量是随着类的加载而完成,因此可以直接定义创建。
		Chinese.nation = "中国";
		
		Chinese c1 = new Chinese();
		c1.name = "张三";
		c1.age = 40;
		
		Chinese c2 = new Chinese();
		c2.name = "李四";
		c2.age = 20;

		System.out.println(c1.nation);
		System.out.println(c2.nation);
	}
	
}

class Chinese{
	String name;
	int age;
	static String nation;
}

1.2 static 内存存储解析

其实,将栈,堆,方法区这几个概念和作用理解好,就知道这几个内存解析了。

1.3 static 修饰方法


静态方法和静态变量一样,也是随着类的加载而加载,可以直接通过"类.静态方法"的方式进行调用,而不是先声明对象才能调用。


最重要的是,静态方法中,只能调用静态的方法和属性。

非静态方法中,既可以调用非静态方法和属性,也可以调用静态方法和属性。

package com.itholmes.p2;

public class StaticTest {
	public static void main(String[] args) {
		Chinese.eat();
	}
	
}

class Chinese{
	String name;
	int age;
	static String ate;
	
	public static void eat() {
		System.out.println("吃饭"+ate);
	}
}

在静态方法中,不能使用this,super等关键字。

this和super必须基于当前对象或当前对象的父类,连对象都没有创建那就更不用提调用了它们了。

1.4 开发中,如何判断是否设置为静态属性或方法

就是共享不共享,属性都统一,方法也都统一(例如:Math,Arrays等等方法)。

2. 单例(Singleton) 设计模式


单例设计模式:对某个类只能存在一个对象实例!

因此,这个设计模式仅仅适合只有一个对象的场景比较适合使用。


单例的饿汉式设计:

package com.itholmes.p2;

public class SingletonTest {
	public static void main(String[] args) {
		//4.静态调用的创建Bank对象。
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		
		System.out.println(bank1 == bank2);
		//这两个共用的一个设计对象
	}
}

// 这种方式调用叫做 饿汉式。
class Bank{
	
	//1.私有化类的构造器,私有化目的:就是为了防止外部创建对象。
	private Bank() {
		
	}
	
	//2.在内部可以创建类的对象,这里骑士可以看成一个属性
	private static Bank instance = new Bank();
	
	//3.提供公共的方法,返回类的对象
	public static Bank getInstance() {
		return instance;
	}
}

单例的懒汉设计:

package com.itholmes.p2;

public class SingletonTest2 {
	
	Order order1 = Order.getInstance();
	Order order2 = Order.getInstance();
	
}

//这种设计模式为懒汉式,其实饿汉式和懒汉式差不多。
class Order{
	
	//1.私有化类的构造器
	private Order() {	
	}
	
	//2.声明当前类的对象
	private static Order instance = null;
	
	//3.声明public static的返回当前类对象的方法
	public static Order getInstance() {
		if(instance == null) {
			instance = new Order();
		}
		return instance;
	}
	
}

单例(Singleton)设计模式的应用场景:


3. Main方法


如果一个类中,有两个main方法一般在运行的时候会提示你选择哪一个main方法作为入口。

package com.itholmes.p2;

public class MainTest {
	public static void main(String[] args) {
		Main.main(new String[100]);
	}
}

class Main{
	public static void main(String[] args) {
		for(int i=0;i<args.length;i++) {
			args[i] = "args_" + i;
			System.out.println(args[i]);
		}
	}
}

一般我们在命令行直接给添加参数,给main方法。

eclipse可以使用Arguments来给main方法添加参数。

4. 代码块


代码块的作用就是用来初始化类,对象。

代码块分两种:静态代码块和非静态代码块


静态代码块:

  • 内部可以有输出语句(Syso)。
  • 静态代码块可以随着类的加载而执行。
  • 静态代码块只执行一次!
  • 如果一个类定义了多个代码块(静态和非静态),就按张声明的先后顺序执行。因为它是随着类的创建加载而声明。
  • 此外,静态代码块要优先非静态代码块,因为静态是随着类的创建加载而产生,后者是因为对象的创建加载。
  • 静态代码块只能调用静态属性方法结构,不能调用非静态的结构。

静态代码块作用:初始化一些类的静态属性信息等等。


非静态代码块:

  • 内部也可以有输出语句(Syso)。
  • 随着类对象的创建而加载执行。
  • 每创建一个对象,就执行一次静态代码块。

因为具备上面的这些特点,因此,非静态代码块的功能就是在创建对象时,对对象的属性等进行初始化。

对属性初始化的总结:


最重要的一点,有继承效果的,一定区分好super()和this()的一些调用,以及静态和非静态代码块的执行顺序,前者伴随的类,后者伴随着对象。

5. final 关键字


final 用来修饰类,方法,变量。

本意就是最后一个!

  • 被final修饰的类,不能被其他类所继承。例如:String类,System类,StringBuffer类,都是final类。
  • 被final修饰的方法,表名此方法不能被重写。例如:Object类中getClass()方法。
  • 被final修饰变量(属性),此时这里的变量就称为一个常量,不能改变值了。

final修饰变量,对于赋值对应有:显示初始化,代码块初始化,构造器初始化。

声明了final变量,但是没有赋值,想从调用方法中传递赋值,这是不行的!!

换句话说,final声明的变量,必须要有赋值。

一个小细节:final声明的变量名一般为大写,因为常量么。


形参使用final声明:(其实,就是传递给过来的数据形参也成了不可改变。

static可以修饰属性,方法,代码块,内部类。(不能修饰构造器)
final可以修饰属性,方法,其他不可以。

6. 抽象类 和 抽象方法


abstract关键字可以用来修饰:类,方法。

abstract关键字:修饰类(抽象类)

  • abstract声明的类不能被实例化(不能创建对象)。
  • 抽象类中一定有构造器!虽然自己不能定义对象了,但是子类还是要用的!!!
  • 开发中,一定提供抽象类的子类,让子类对象实例化,完成相关操作。

abstract关键字:修饰方法(抽象方法)

  • 抽象方法只有方法的声明,没有方法体!!
  • 包含抽象方法的类,一定是一个抽象类。反之,抽象类中是可以没有抽象方法。
  • 当然,如果父类是抽象类里面还有抽象方法,这样子类要么重写这个抽象方法,要么将子类也定义为abstract抽象类。
package com.itholmes.p2;

public class AbstractTest {
	public static void main(String[] args) {
		//因为抽象类是不能实例化的
//		PersonX p1 = new PersonX();
//		p1.eat();
	}
}


abstract class PersonX {
	String name;
	int age;
	
	public PersonX() {
		
	}
	
	public PersonX(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public abstract void eat();
	
	public void walk() {
		System.out.println("人们走路");
	}
}

//要么将该类定义为抽象类(因为父类含有抽象类)
abstract class Student extends PersonX{
	
	public Student(String name,int age) {
		super(name,age);
	}
	
	//要么重写eat()类
//	@Override
//	public void eat() {
//		System.out.println("学生吃饭");
//	}
	
}


abstract的注意事项:

  • abstract不能用来修饰:属性,构造器等结构。
  • abstract不能用来修饰私有方法(private不能被重写),静态方法(子父类的同名同参数的静态方法,不能重写!),final的方法和类。

7. 匿名类

对于abstract声明的类,不能创建对象,但是可以创建一个匿名类的对象。

package com.itholmes.p2;

public class AbstractTest {
	public static void main(String[] args) {
		
		//这就是一个匿名的子类对象:p
		PersonX p = new PersonX() {
			@Override
			public void eat() {
				System.out.println("匿名类创建");
			}
		};
		
	}
}


abstract class PersonX {
	String name;
	int age;
	
	public PersonX() {
		
	}
	
	public PersonX(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public abstract void eat();
	
	public void walk() {
		System.out.println("人们走路");
	}
}

8. 模板方法设计模式


其实整体上,就是通过继承外加abstract抽象方法,来实现一种模板方式。
就像下面代码的code()部分一样。

package com.itholmes.p2;

public class TemplateTest {
	public static void main(String[] args) {
		Template tem = new SubTemplate();
		
		tem.spendTime();
	}
}
 
abstract class Template{
	
	public void spendTime() {
		
		long start = System.currentTimeMillis();
		
		//这里的code代码就是不确定的部分。
		this.code(); //this指的就是当前对象,这里指的就是tem,tem.code()是重写后的code方法。
		
		long end = System.currentTimeMillis();
		
		System.out.println("花费的时间为:"+ (end - start));
	}
	
	public abstract void code();
}

class SubTemplate extends Template{
	@Override
	public void code() {
		for(int i=2;i<=1000;i++) {
			boolean isFlag = true;
			for(int j=2;j<=Math.sqrt(i);j++) {
				if(i%j ==0) {
					isFlag = false;
					break;
				}
			}
			if(isFlag) {
				System.out.println(i);
			}
		}
	}
}

9. 接口


接口和类是两个并列的结构。



JDK7 以前版本仅仅定义了全局常量和抽象方法:

  • 全局常量:public static final的类型,可以省略不写。
  • 抽象方法:public abstract的类型,也可以省略不写。

JDK8除了定义全局常量和抽象方法,还定义了静态方法,默认方法。

  • 接口不能定义构造器。意味着接口不能实例化。

  • Java开发中,接口通过让类去实现(implements)的方法来使用。

  • 需要注意的是,如果实现类对应接口有抽象方法,就要对应对抽象方法的重写或将实现类定义为抽象方法。

  • 可以implements多个接口,弥补了Java单继承性的局限性。
    格式:class 类名 extends 父类 implements 接口1,接口2,接口3

  • 接口和接口之间是可以继承的,多继承。

  • 接口具有多态性,因此,实现类可以对应接口创建对象。

10.接口 匿名类和匿名对象

主要四种情况:

package com.itholmes.p2;

public class USBTest {
	public static void main(String[] args) {
		Computer com = new Computer();
		
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		com.transferDate(flash);
		
		//2.创建了接口的非匿名实现类的匿名对象
		com.transferDate(new Printer());
		
		//3.创建了接口的匿名实现类的非匿名对象
		USB phone = new USB() {
			@Override
			public void start() {
				// TODO Auto-generated method stub
				System.out.println("手机开始工作");
			}
			@Override
			public void stop() {
				// TODO Auto-generated method stub
				System.out.println("手机结束工作");
			}
		};
		com.transferDate(phone);
		
		//4. 创建了接口的匿名实现类的匿名对象
		com.transferDate(new USB() {
			@Override
			public void start() {
				// TODO Auto-generated method stub
				System.out.println("MP4开始工作");
			}
			@Override
			public void stop() {
				// TODO Auto-generated method stub
				System.out.println("MP4结束工作");
			}	
		});
	}
}

class Computer{
	public void transferDate(USB usb) {
		usb.start();
		System.out.println("具体传输数据的细节");
		usb.stop();
	}
}

interface USB{
	
	void start();
	
	void stop();
}

class Flash implements USB{

	@Override
	public void start() {
		// TODO Auto-generated method stub
		System.out.println("U盘开始工作");
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		System.out.println("U盘结束工作");
	}
	
}

class Printer implements USB{

	@Override
	public void start() {
		// TODO Auto-generated method stub
		System.out.println("打印机开始工作");
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		System.out.println("打印机结束工作");
	}
	
}

11. 接口应用 代理模式(Proxy)

代理模式,就是为其它对象提供一种代理以控制对这个对象的访问。 理解好,代理类和非代理类就可以了。

package com.itholmes.p2;

public class NetWorkTest {
	
	public static void main(以上是关于Java 基础知识点 笔记总结 的主要内容,如果未能解决你的问题,请参考以下文章

关于JAVA 反射 基础知识/编码经验的一些总结

关于JAVA 异常 基础知识/编码经验的一些总结

关于JAVA 反射 基础知识/编码经验的一些总结

关于JAVA 异常 基础知识/编码经验的一些总结

Java 基础知识点 笔记总结

Java 基础知识点 笔记总结