JAVA基础学习入门（九）

本文主要是介绍JAVA基础学习入门（九），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

关键字static

单例模式

/**
 * 单例设计模式
 * 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
 * 
 * 2.如何实现？
 * @author 123
 *
 * 3.区分饿汉式和懒汉式
 *   饿汉式：
 *      坏处：对象加载时间过长
 *      好处：饿汉式是线程安全的
 *     
 *   懒汉式：
 *      好处：延迟对象的创建
 *      目前写法坏处：线程不安全---->到多线程内容时，再修改
 */

public class SingletonTest1 {
	public static void main(String[] args) {
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		
		System.out.println(bank1.equals(bank2));
	}

}
//饿汉式
class Bank{
	//1.私有化类的构造器
	private Bank(){
		
	}
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}

/**
 * 单例模式的懒汉式实现
 * @author 123
 *
 */

public class SingletonTest2 {
	

}
class Order{
	//1.私有化类的构造器
	private Order(){
		
	}
	//2.声明当前类对象，没有初始化
	//4.此对象必须声明为static的
	private static Order instance = null;
	
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		if(instance == null){
			instance = new Order();
		}
		return instance;
	}
}

单例模式的优点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
举例：java.lang.Runtime
单例模式–应用场景
1.网站计数器
2.应用程序的日志应用
3.数据库连接池
4.项目中，读取配置文件的类
5.Apllication
6.Windows的Task Manager(任务管理器)
7.Windows的Recycle Bin(回收站)

理解main方法语法

/**
 * main()方法的使用说明：
 * 1.main()方法作为程序的入口
 * 2.main()方法也是一个普通的静态方法
 * 3.main()方法可以作为我们与控制台交互的方式。(之前：使用Scanner)
 * @author 123
 *
 */
public class MainTest {
	public static void main(String[] args){//入口
		Main.main(new String[100]);
		MainTest test = new MainTest();
		test.show();
		
	}
	public void show(){
		 
	}

}
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]);
		}
	}
}

public class MainDemo {
	public static void main(String[] args) {
		for(int i = 0; i < args.length; i++){
			System.out.println("*******"+args[i]);
			int num = Integer.parseInt(args[i]);
			System.out.println("######"+num);
		}
	}
}

代码块

/**
 * 类的成员：代码块(或初始化块)
 * 1.代码块的作用：用来初始化类、对象
 * 2.代码块如果有修饰的话只能用static
 * 3.分类：静态代码块 vs 非静态代码块
 * 4.静态代码块
 *    >内部可以有输出语句
 *    >随着类的加载而执行,而且只执行一次，除非类被重新加载，优先于构造器
 *    >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
 *    >静态代码块的执行要优先于非静态代码块的执行
 *    >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
 * 5.非静态代码块
 *    >内部可以有输出语句
 *    >随着对象的创建而执行，而且每创建一个对象就执行一次非静态代码块
 *    >作用：可以在创建对象时，对对象的属性等进行初始化
 *    >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行，但是其整体要晚于静态代码块，优先于构造器
 *    >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、方法
 *    
 * 对属性可以赋值的位置：
 * ①默认初始化
 * ②显式初始化/⑤在代码块中赋值
 * ③构造器中初始化
 * ④有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值
 * 执行的先后顺序：①-②/⑤-③-④
 * @author 123
 *
 */
public class BlockTest {
	public static void main(String[] args) {
		String desc = Person.desc;
		Person p1 = new Person();
		Person p2 = new Person();
		
		Person.info();
	}

}
class Person{
	String name;
	int age;
	static String desc = "我是一个人";
	//构造器
	public Person(){
		System.out.println("hello！！！");
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	//static代码块
	static{
		System.out.println("hello, static block-1");	
	}
	//static代码块
	static{
		System.out.println("hello, static block-2");
		//调用静态结构
		desc = "www.com.com";
		info();
	}
	//非static代码块
	{
		System.out.println("hello, block");	
		//调用静态结构
		desc = "www.com.com.com";
		info();
		//调用非静态结构
		age = 19;
		eat();
	}
	//方法
	public void eat(){
		System.out.println("吃饭");
	}
	@Override
	public String toString(){
		return "Person [name=" + name +",age="+ age +"]";
	}
	public static void info(){
		System.out.println("www.com");
	}
	
}

关键字：final

final可以用来修饰的结构：类、方法、变量
final用来修饰一个类:此类不能被其他类所继承。比如：String类、System类、StringBuffer类
final用来修饰方法，表明此方法不可以被重写。比如Object类中getClass();
final用来修饰变量，此时的“变量”就称为一个常量

final修饰属性，可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值

static final 用来修饰属性：全局常量（只能用于修饰属性和方法）

抽象类与抽象方法

abstract:抽象的
abstract可以用来修饰的结构：类、方法
abstract修饰类：抽象类

此类不能实例化
此类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

abstract修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类
若子类重写了父类中的所有的抽象方法后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法后，则此子类也是一个抽象类，需要使用abstract修饰。

abstract使用上的注意点

abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰私有方法、静态方法、final的方法、final的类

抽象类的应用：模板方法的设计模式

import javax.swing.plaf.synth.SynthSeparatorUI;

/**
 * 抽象类的应用：模板方法的涉及模式
 * @author 123
 *
 */

public class TemplateTest {
	public static void main(String args[]){
		SubTemplate t = new SubTemplate();
		t.spendTime();
	}
	

}
abstract class Template{
	//计算某段代码执行所需要花费的时间
	public void spendTime(){
		long start = System.currentTimeMillis();
		this.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;
				}
			}
			if(isFlag){
				System.out.println(i);
			}
		}
	}
}

//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {

	public static void main(String[] args) {
		BankTemplateMethod btm = new DrawMoney();
		btm.process();

		BankTemplateMethod btm2 = new ManageMoney();
		btm2.process();
	}
}
abstract class BankTemplateMethod {
	// 具体方法
	public void takeNumber() {
		System.out.println("取号排队");
	}

	public abstract void transact(); // 办理具体的业务 //钩子方法

	public void evaluate() {
		System.out.println("反馈评分");
	}

	// 模板方法，把基本操作组合到一起，子类一般不能重写
	public final void process() {
		this.takeNumber();

		this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

		this.evaluate();
	}
}

class DrawMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要取款！！！");
	}
}

class ManageMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要理财！我这里有2000万美元!!");
	}
}

接口(interface)

/**
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.java中，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口中的成员
 *    3.1JDK7.0及其以前，只能定义全局常量和抽象方法
 *        >全局常量：public static final 的 但是书写时，可以省略不写
 *        >抽象方法：public abstract 的
 *    3.2JDK8.0：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)                                                                                                                                                                                                      
 * 4.接口中不能定义构造器的！意味着接口不可以实例化
 * 5.java开发中，接口通过让类去实现(implement)的方式来使用
 *    如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
 *    如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
 * 6.java类可以实现多个接口--->弥补了java单继承性的局限性
 *    格式：class AA extends BB implements CC,DD,EE
 * 7.接口与接口之间可以继承，而且可以多继承
 * ********************************************
 * 8.接口的具体使用，体现多态性
 * 9.接口，实际上可以看做是一种规范
 * 
 * 
 * @author 123
 *
 */
public class InterfaceTest {
	public static void main(String[] args){
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
		Plane plane = new Plane();
		plane.fly();
	}

}
interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED =1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
}
interface Attackable{
	void attack();
}
class Plane implements Flyable{
	@Override 
	public void fly(){
		System.out.println("通过引擎起飞");
	}
	@Override 
	public void stop(){
		System.out.println("驾驶员减速停止");
	}
}
class Bullet extends Object implements Flyable,Attackable,CC{
	@Override 
	public void attack(){
		
	}
	@Override 
	public void fly(){
		
	}
	@Override 
	public void stop(){
		
	}
	@Override 
	public void method1(){
		
	}
	@Override 
    public void method2(){
		
	}
}

//****************************************************************
interface AA{
	void method1();
}
interface BB{
	void method2();
}
interface CC extends AA,BB{
	
}

代理模式：就是让代理去处理被代理者该做的事情，同时也做了被代理者无法做的事情

/**
 * 接口的应用：代理模式
 * @author 123
 *
 */
public class NetworkTest {
	public static void main(String[] args) {
		Server server = new Server();
		ProxyServer proxyserver = new ProxyServer(server);
		proxyserver.browse();
	}
}
interface Network{
	public void browse();
}
//被代理类
class Server implements Network{
	@Override
	public void browse(){
		System.out.println("真实的服务器访问网络");
	}
}
//代理类
class ProxyServer implements Network{
	private Network work;
	public ProxyServer(Network work){
		this.work = work;
	}
	public void check(){
		System.out.println("联网之前的检查工作");
	}
	@Override
	public void browse(){
		check();
		work.browse();
	}
}

public class StaticProxyTest {

	public static void main(String[] args) {
		Star s = new Proxy(new RealStar());
		s.confer();
		s.signContract();
		s.bookTicket();
		s.sing();
		s.collectMoney();
	}
}

interface Star {
	void confer();// 面谈

	void signContract();// 签合同

	void bookTicket();// 订票

	void sing();// 唱歌

	void collectMoney();// 收钱
}

class RealStar implements Star {

	public void confer() {
	}

	public void signContract() {
	}

	public void bookTicket() {
	}

	public void sing() {
		System.out.println("明星：歌唱~~~");
	}

	public void collectMoney() {
	}
}

class Proxy implements Star {
	private Star real;

	public Proxy(Star real) {
		this.real = real;
	}

	public void confer() {
		System.out.println("经纪人面谈");
	}

	public void signContract() {
		System.out.println("经纪人签合同");
	}

	public void bookTicket() {
		System.out.println("经纪人订票");
	}

	public void sing() {
		real.sing();
	}

	public void collectMoney() {
		System.out.println("经纪人收钱");
	}
}

public class SubClassTest {
	public static void main(String[] args){
		SubClass s = new SubClass();
//		s.method1();
//		SubClass.method1();
		//知识点1：接口中定义的静态方法，只能通过接口来调用
		CompareA.method1();
		//知识点2：通过实现类的对象，可以调用接口中的默认方法
		//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
		s.method2();
		//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的方法，
		//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法-->类优先原则
		s.method3();
		//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
		//这就需要我们必须在实现类中重写此方法
	}

}
class SubClass extends SuperClass implements CompareA,Compare8{
	public void method2(){
	    System.out.println("上海11");
	}
	//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
	public void myMethod(){
		method3();//调用自己定义的重写方法
		super.method3();//调用的是父类中声明的
		//调用调用接口中的默认方法
		CompareA.super.method3();
		Compare8.super.method3();
	}
}
public interface CompareA {
	//静态方法
	public static void method1(){
		System.out.println("北京");
	}
	//默认方法
    public default void method2(){
	    System.out.println("上海");
	}
    default void method3(){
	    System.out.println("广州");
	}

}
public class SuperClass {
	public void method3(){
		System.out.println("Super:北京");
	}

}
public interface Compare8 {
	default void method3(){
	    System.out.println("Compare8:广州");
	}

}

内部类

/**
 * 内部类
 * 1.java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
 * 2.内部类的分类：成员内部类(静态、非静态)vs局部内部类(方法内、代码块内、构造器内)
 * 3.成员内部类：
 *      一方面，作为外部类的成员：
 *        >调用外部类的结构
 *        >可以被static修饰
 *        >可以被四种不同的权限修饰
 *      
 *      另一方面，作为一个类：
 *        >类内可以定义属性、方法、构造器等
 *        >可以被final修饰，表示此类不能被继承。否则可以被继承
 *        >可以被abstract修饰
 * 4.关注如下3个问题：
 *   4.1如何实例化成员内部类的对象
 *   4.2如何在成员内部类中区分调用外部类的结构
 *   4.3开发中局部内部类的使用
 * @author 123
 *
 */

public class InnerClassTest {
	public static void main(String[] args){
		
		//创建Dog实例(静态的成员内部类)
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类)
		//Person.Bird bird = new Person.Bird();//错误的，必须先实例化Person类再通过对象去调用
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		bird.display("黄鹂");
	}

}
class Person{
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	//静态成员内部类
	static class Dog{
		String name;
		int age;
		public void show(){
			System.out.println("卡拉是条狗");
		}
	}
	//非静态成员内部类
    final class Bird{
		String name = "杜鹃";
		public Bird(){
			
		}
		public void sing(){
			System.out.println("我是一只小鸟");
			Person.this.eat();//调用外部类属性
			eat();
		}
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性
		}
	}
	public void method(){
		//局部内部类
		class AA{
			
		}
	}
	{
		//局部内部类
		class BB{
			
		}
	}
	public Person(){
		//局部内部类
		class CC{
			
		}
	}
}

public class InnerClassTest1 {
	
	//开发中很少见
	public void method(){
		//局部内部类
		class AA{
			
		}
	}
	//返回了一个实现了Comparable接口的类的对象
	public Comparable getComparable(){
//		//创建了一个实现了Comparable接口的类:局部内部类
//		//方法一
//		class MyComparable implements Comparable{
//			@Override
//			public int compareTo(Object o){
//				//
//				return 0;
//			}
//		}
//		return new MyComparable();
		//方式二
		return new Comparable(){
			@Override
			public int compareTo(Object o){
				return 0;
			}
		};
	}

}

这篇关于JAVA基础学习入门（九）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

JAVA基础学习入门（九）

关键字static

单例模式

理解main方法语法

代码块

关键字：final

抽象类与抽象方法

接口(interface)

内部类

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯