Java面向对象详解-下

标签：tor   关键词   ati   使用   子类   多少   内部类   turn   double   

一、 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);
				
			}	
		}	
	}
}

Java面向对象详解-下

标签：tor   关键词   ati   使用   子类   多少   内部类   turn   double   

原文地址：https://www.cnblogs.com/mengd/p/13281626.html