Java面向对象详解-下

一、 static

  1. static:静态的,可以用来修饰属性、方法、代码块(或初始化块)、内部类
  2. static修饰属性(类变量):
    • 由类创建的所有的对象,都共用这一个属性
    • 当其中一个对象对此属性进行修改,会导致其他对象对此属性的一个调用。vs 实例变量(非static修饰的属性,各个对象各自拥有一套副本)
    • 类变量随着类的加载而加载的,而且独一份
    • 静态的变量可以直接通过“类.类变量”的形式来调用
    • 类变量的加载是要早于对象。所以当有对象以后,可以“对象.类变量”使用。但是"类.实例变量"是不行的。
    • 类变量存在于静态域中。
  3. static修饰方法(类方法):
    • 随着类的加载而加载,在内存中也是独一份
    • 可以直接通过“类.类方法”的方式调用
    • 内部可以调用静态的属性或静态的方法,而不能调用非静态的属性或方法。反之,非静态的方法是可以调用静态的属性或静态的方法
    • 静态的方法内是不可以有this或super关键字的!
    • 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构,同时被回收也要晚于非静态的结构
  4. 开发中,如何确定一个属性是否要有声明为static的?
    • 属性可以被多个对象共享的,不会随着对象的不同而不同
  5. 开发中,如何确定一个方法是否要有声明为static的?
    • 操作静态属性的方法通常也是静态的
    • 工具类中对 方法通常也为static的
public class TestCircle {
	public static void main(String[] args) {
		Circle c1 = new Circle();
		Circle c2 = new Circle(2.3);
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(Circle.getTotal());
	}
}
 
class Circle{
	private double radius;
	private static String info = "我是一个圆";
	private int id;//编号
	private static int init = 1001;//控制每个对象的id
	private static int total = 0;//记录创建了多少个对象
	
	public Circle(){
		this.id = init++;
		total++;
	}
	public Circle(double radius){
		this.radius = radius;
		this.id = init++;
		total++;
	}
	
	
	
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public static String getInfo() {
		return info;
	}
	public static void setInfo(String info) {
		Circle.info = info;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public static int getTotal() {
		return total;
	}
	public static void setTotal(int total) {
		Circle.total = total;
	}
	@Override
	public String toString() {
		return "Circle [radius=" + radius + ", id=" + id + "]";
	}
	public static void show(){
		System.out.println(Circle.info);
	}
	
	public void desc(){
		System.out.println(this.info);
	}

}

二、单例设计模式

解决的问题:如何只让设计的类只能创建一个对象
如何实现:饿汉式 & 懒汉式

1. 饿汉式1

class Bank{
	//1.私有化构造器
	private Bank(){}
	//2.创建类的对象,同时设置为private的,通过公共的来调用,体现封装性
	//4.要求此对象也为static的
	private static Bank instance = new Bank();
	//3.此公共的方法,必须为static 
	public static Bank getInstance(){
		return instance;	
	}
}

2. 饿汉式2

class Bank{
	//1.私有化构造器
	private Bank(){}
	//2.创建类的对象,同时设置为private的,通过公共的来调用,体现封装性
	//4.要求此对象也为static的
	private static Bank instance = null;
	static{
		instance  = new Bank();	
	}
	//3.此公共的方法,必须为static  
	public static Bank getInstance(){
		return instance;	
	}
}

3. 懒汉式

class Bank{
	private Bank(){}
	
	private static Bank instance = null;
	
	public static Bank getInstance(){
		if(instance == null){//可能存在线程安全问题的!
			instance = new Bank();		
		}	
		return instance;
	}
}

三、main()方法

public static void main(String[] args){
     //方法体     
}

//1.main()是一个方法,是主方法,为程序的入口
//2.权限修饰符:public protected 缺省 private ---面向对象的封装性
//3.对于方法来讲:static final abstract 
//4.方法的返回值:void /  具体的返回值类型(基本的数据类型 & 引用数据类型),方法内部一定要有return
//5.方法名:命名的规则:xxxYyyZzz。给方法命名时,要见名之意
//6.形参列表:同一个方法名不同的形参列表的诸多个方法间构成重载。   形参 & 实参---方法的参数传递机制:值传递
//7.方法体:方法定义的是一种功能,具体的实现由方法体操作。

四、代码块

  1. 代码块:是类的第4个成员 { }
    作用:用来初始化类的属性
    分类:只能用static来修饰。
  2. 静态代码块:
    • 里面可以有输出语句
    • 随着类的加载而加载并且执行,而且只被加载一次
    • 多个静态代码块之间按照顺序结构执行
    • 静态代码块的执行要早于非静态代码块的执行。
    • 静态的代码块中只能执行静态的结构(类属性,类方法)
  3. 非静态代码块:
    • 可以对类的属性(静态的 & 非静态的)进行初始化操作,同时也可以调用本类声明的方法(静态的 & 非静态的)
    • 里面可以有输出语句
    • 一个类中可以有多个非静态的代码块,多个代码块之间按照顺序结构执行
    • 每创建一个类的对象,非静态代码块就加载一次。
    • 非静态代码块的执行要早于构造器
  4. 关于属性赋值的操作:
    • 默认的初始化
    • 显式的初始化或代码块初始化(此处两个结构按照顺序执行)
    • 构造器中;
    • 以上是对象的属性初始化的过程------
    • 通过方法对对象的相应属性进行修改

1. 常见问题

总结:由父及子,静态先行

class Root{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root(){
		super();
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid(){
		super();
		System.out.println("Mid的无参数的构造器");
	}
	public Mid(String msg){
		//通过this调用同一类中重载的构造器
		this();
		System.out.println("Mid的带参数构造器,其参数值:"
			+ msg);
	}
}
class Leaf extends Mid{
	static{
		System.out.println("Leaf的静态初始化块");
	}
	{
		System.out.println("Leaf的普通初始化块");
	}	
	public Leaf(){
		//通过super调用父类中有一个字符串参数的构造器
		super("尚硅谷");
		System.out.println("Leaf的构造器");
	}
}
public class LeafTest{
	public static void main(String[] args){
		new Leaf(); 
		System.out.println();
		new Leaf();
	}
}


package com.atguigu.java3;

class Father {
	static {
		System.out.println("11111111111");
	}
	{
		System.out.println("22222222222");
	}

	public Father() {
		System.out.println("33333333333");

	}

}

public class Son extends Father {
	static {
		System.out.println("44444444444");
	}
	{
		System.out.println("55555555555");
	}
	public Son() {
		System.out.println("66666666666");
	}


	public static void main(String[] args) { // 由父及子 静态先行
		System.out.println("77777777777");
		System.out.println("************************");
		new Son();
		System.out.println("************************");
		new Son();
		System.out.println("************************");
		new Father();
	}

}

五、final关键词

final:最终的 ,可以用来修饰类、属性、方法

  1. final修饰类:这个类就不能被继承。如:String类、StringBuffer类、System类
  2. final修饰方法:不能被重写。如:Object类的getClass()
  3. final修饰属性:此属性就是一个常量,一旦初始化后,不可再被赋值。习惯上,常量用大写字符表示
    此常量在哪里赋值:①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
  4. 变量用static final修饰:全局常量。比如:Math 类的PI
class D{
	final int I = 12;
	final double PI;
	final String NAME;

	public void m1(){
		System.out.println(I);
//		I = 10;

	}
	{
		PI = 3.14;
	}
	
	public D(){
		NAME = "DD";
	}
	public D(String name){
		this();
		//NAME = name;
	}
}

六、抽象 abstract

abstract:抽象的,用来修饰类、方法

  1. abstract修饰类:抽象类
    • 不可被实例化
    • 抽象类有构造器 (凡是类都有构造器),便于子类实例化时调用
    • 抽象方法所在的类,一定是抽象类
    • 抽象类中可以没有抽象方法。
    • 当我们设计一个类,不需要创建此类的实例时候,就可以考虑将其设置为抽象的,由其子类实现这个类的抽象方法以后,就行实例化
  2. abstract修饰方法:抽象方法
    • 格式:没有方法体,包括{}.如:public abstract void eat();
    • 抽象方法只保留方法的功能,而具体的执行,交给继承抽象类的子类,由子类重写此抽象方法
    • 若子类继承抽象类,没有重写所有的抽象方法,意味着此类中仍有抽象方法,则此类必须声明为抽象的

1. 模板方法设计模式

//模板方法设计模式
public class TestTemplate {
	public static void main(String[] args) {
		new SubTemplate().spendTime();
	}
}

abstract class Template {

	public abstract void code();

	public void spendTime() {
		long start = System.currentTimeMillis();

		this.code();

		long end = System.currentTimeMillis();
		System.out.println("花费的时间为:" + (end - start));
	}
}

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

2. 抽象类的应用

//抽象类的应用:模板方法的设计模式
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

接口(interface) 是与类并行的一个概念

  1. 接口可以看做是一个特殊的抽象类是常量(public static final 可以省略)与抽象方法的一个集合,不能包含变量、一般的方法。
  2. 接口是没有构造器的
  3. 接口定义的就是一种功能。此功能可以被类所实现(implements)
    比如:class CC extends DD implements AA
  4. 实现接口的类,必须要重写其中的所有的抽象方法,方可实例化。若没有重写所有的抽象方法,则此类仍为一个抽象类
  5. 类可以实现多个接口。----java 中的类的继承是单继承的
  6. 接口与接口之间也是继承的关系,而且可以实现多继承

5,6描述的是java中的继承的特点。

  1. 接口与具体的实现类之间也存在多态性

1. 接口的使用

  • 接口使用上也满足多态性
  • 接口,实际上就是定义了一种规范
  • 面向接口编程
public class USBTest {
	public static void main(String[] args) {
		
		Computer com = new Computer();
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		com.transferData(flash);
		
		//2. 创建了接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
		
		//3. 创建了接口的匿名实现类的非匿名对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
			
		};
		com.transferData(phone);
		
		
		//4. 创建了接口的匿名实现类的匿名对象
		
		com.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("mp3开始工作");
			}

			@Override
			public void stop() {
				System.out.println("mp3结束工作");
			}
		});
	}
}

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

interface USB{
	//常量:定义了长、宽、最大最小的传输速度等
	
	void start();
	
	void stop();
	
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
	
}

class Printer implements USB{
	@Override
	public void start() {
		System.out.println("打印机开启工作");
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
	
}


2. 工厂方法的设计模板

//接口的应用:工厂方法的设计模式
public class TestFactoryMethod {
	public static void main(String[] args) {
		IWorkFactory i = new StudentWorkFactory();
		i.getWork().doWork();
		
		IWorkFactory i1 = new TeacherWorkFactory();
		i1.getWork().doWork();
	}
}

interface IWorkFactory{
	Work getWork();
}
class StudentWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new StudentWork();
	}
	
}
class TeacherWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new TeacherWork();
	}
	
}

interface Work{
	void doWork();
}

class StudentWork implements Work{

	@Override
	public void doWork() {
		System.out.println("学生写作业");
	}
	
}
class TeacherWork implements Work{

	@Override
	public void doWork() {
		System.out.println("老师批改作业");
	}
}

3. 代理模式

//接口的应用:代理模式(静态代理)
public class TestProxy {
	public static void main(String[] args) {
		Object obj = new ProxyObject();
		obj.action();
	}
}

interface Object{
	void action();
}
//代理类
class ProxyObject implements Object{
	Object obj;
	
	public ProxyObject(){
		System.out.println("代理类创建成功");
		obj = new ObjctImpl();
	}
	
	public void action(){
		System.out.println("代理类开始执行");
		obj.action();
		System.out.println("代理类执行结束");
	}
}
//被代理类
class ObjctImpl implements Object{

	@Override
	public void action() {
		System.out.println("=====被代理类开始执行======");
		System.out.println("=====具体的操作======");
		System.out.println("=====被代理类执行完毕======");
		
	}
	
}

4. 问题

interface A {
	int x = 0;
}

class B {
	int x = 1;
}

class C extends B implements A {
	public void pX() {
		//编译不通过。因为x是不明确的
		// System.out.println(x);
		System.out.println(super.x);//1
		System.out.println(A.x);//0
	}

	public static void main(String[] args) {
		new C().pX();
	}
}

5. Java8新特性

八、内部类

Java中允许将一类A声明在类B中,则类A就是内部类

1. 成员内部类(静态、非静态)

  • 作为一个类
    • 类内可以定义属性、方法、构造器
    • 可以被final修饰,表示此类不能继承,也就是不适用final,就可以被继承
    • 可以被abstract修饰
  • 作为外部类的
    • 调用外部类的结构
    • 可以被static修饰
    • 可以被4种不同的权限修饰

局部内部类(方法内、代码块、构造器中)

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 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("卡拉是条狗");
//			eat();
		}
		
	}
	//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一只小小鸟");
			Person.this.eat();//调用外部类的非静态属性
			eat();
			System.out.println(age);
		}
		
		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{
			
		}
	}
	
}

2. 注意

package com.atguigu.java;

public class InnerClassTest {
	/*
	 * 在局部内部类声明的方法中(比如:show)如果调用局部内部类所声明的方法(比如:method)中的局部变量(比如:num)的话,
	 * 要求此局部变量声明为final的。
	 * 
	 * jdk 7及之前版本:要求此局部变量显式的声明为final的
	 * jdk 8及之后的版本:可以省略final的声明
	 * 
	 */
	public void method(){
		//局部变量
		int num = 10;
		
		class AA{	
			public void show(){
//				num = 20;
				System.out.println(num);
				
			}	
		}	
	}
}
posted @ 2020-07-10 22:23  山丘i  阅读(431)  评论(0编辑  收藏  举报