JAVA学习_2面向对象

最新推荐文章于 2024-07-14 22:26:46 发布

yaxi_wx

最新推荐文章于 2024-07-14 22:26:46 发布

阅读量336

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/yaxi_wx/article/details/38051351

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

封装

1、四种访问权限：private、default、protected和public

private：当前类访问权限

default：包访问权限，当不使用任何访问权限符修饰的时候，系统默认为default访问权限

protected：子类访问权限，这个访问权限的设定是为了方便子类重写

public：公共访问权限

2、 super限定：用super限定可以调用父类已经被子类重写覆盖的实例方法。

比如父类有一个变量是a，子类进行了重写，如果要重新调用出父类的这个变量的值，就可以用super.a来调用。

类成员

1、单例类：（Singleton）

该类始终只创建一个实例。实现方法是用private来隐藏构造器，用一个成员函数来创建实例的过程中，如果发现已经构造过一个实例，就不再构造新的实例，所以反映出来该类只能构造出一个实例。

public class Singleton {
	private static Singleton instance;//内设一个用例
	
	private Singleton(){}//用private来隐藏构造器
	public static Singleton getInstance(){
		//如果instance是NULL，就创建一个新的实例，否则返回该instance
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}
	
	static public void main(String args[]){
		//如果通过构造器进行构造还是会产生两个不同的实例
		Singleton s1 = new Singleton();
		Singleton s2 = new Singleton();
		//判断两个实例是否是一个
		System.out.println(s1);
		System.out.println(s2);
		if(s1 == s2)System.out.println("the same!");
		
		//通过成员函数创建对象产生的实例就是一样的，即形成了单例类
		Singleton s3 = Singleton.getInstance();
		Singleton s4 = Singleton.getInstance();
		System.out.println(s3);
		System.out.println(s4);
		if(s3 == s4)System.out.println("the same!");
		
		
	}
}

2、final修饰符

final修饰符可以用来修饰变量，方法和类，因为不同的修饰对象final所起的效果有所不同。

i、用final修饰的变量不能被修改，如果在定义的时候没有被初始化，之后最多可以被赋值一次，此后就不能再被修改了。

ii、当final修饰引用变量时，就表示该引用的地址没有发生变化，在该地址上的对象可以发生变化。

iii、final修饰的方法不能被重写，但是可以被重载。

iv、final修饰的类不能有子类。

抽象类

抽象类用abstract进行修饰，抽象类的成员函数可以是抽象函数也可以不是，但含有抽象函数的类只能被定义为抽象类。

抽象类不能被实例化，即不能通过new关键字来调用抽象类的实例。

most important：抽象类中的抽象方法必须在子类中被重写

abstract class Shape{
	{
		System.out.println("执行shape的初始化块");
	}
	private String color;
	public abstract double calPerimeter();
	public abstract String getType();
	public Shape(){}
	public Shape(String color){
		System.out.println("执行shape的构造函数");
		this.color = color;
	}
};
public class Triangle extends Shape{
	private double a;
	private double b;
	private double c;
	public Triangle(String color,double a, double b, double c){
		super(color);
		this.a = a;
		this.b = b;
		this.c = c;
	}
	public double calPerimeter(){
		return a+b+c;
	}
	public String getType(){
		return "这是三角形！";
	}
	
	static public void main(String args[]){
		Triangle T = new Triangle("black",1,2,2);
		System.out.println(T.getType()+" 周长为"+T.calPerimeter());
		
	}
}

接口

【修饰符】 interface 接口名 extends 父接口1，父接口2........{

零到多个常量的定义

零到多个抽象方法的定义

}

important：接口中的方法都是抽象方法；接口只能继承接口，不能继承类。

接口中不包含构造器和初始化块定义。

接口支持多继承，可有多个直接父类。

内部类

1、非静态内部类

2、静态内部类

用static修饰一个内部类，这个内部类属于外部类本身而不属于外部类的某一个对象。

静态内部类不能访问外部类的实例成员，只能访问外部类的类成员，静态内部类只能访问外部类的静态成员。

3、局部内部类

方法中的内部类，不能在外部类的方法以外的地方使用，因此局部内部类不能使用访问控制符和static修饰符进行修饰。

4、匿名内部类

适合创建那种只需要使用一次的类，匿名类不能够重复使用。

实现方式是：new 父类构造器（实参列表）|实现接口（）{

//匿名内部类的类体部分

}

匿名类必须继承一个父类或者实现一个接口，由于匿名类没有类名，所以没有构造器。

interface Thing{
	public double getPrice();
	public String getName();
}
public class AnonymousTest {
	public void test(Thing p){
		System.out.println("购买了一个"+p.getName()+". 花掉了"+p.getPrice());
	}
	public static void main(String []args){
		AnonymousTest ta = new AnonymousTest();
		ta.test(new Thing(){
			public double getPrice(){
				return 567.8;
			}//匿名类的创建
			public String getName(){
				return"AGP显卡";
			}
		});
	}
	
}

对象与垃圾回收

1、对象在内存中的状态

对象在堆内存中运行的时候，可以根据它被引用变量所引用的状态，将其分为三种：

i、可达状态：有引用变量引用

ii、可恢复状态：某个对象不再有任何引用变量引用它，就进入可恢复状态。java的重要功能---垃圾回收机制（GC：garbage collection）会准备回收该对象的内存。在回收之前，系统会调用所有可恢复状态对象的finalize()方法进行资源清理。如果在调用了该方法之后，依旧没有引用变量引用该对象，那么该对象就进入不可达状态。

iii、不可达状态：对象与所有引用变量的关联切掉，且系统在调用了finalize方法之后依旧不能使其有引用变量引用，那么这个对象就已经永远失去了引用，就会被系统收回其占用的资源。

Java常用修饰符的适用范围

	外部类/接口	成员属性	方法	构造器	初始化块	成员内部类	局部成员
public	T	T	T	T		T
protected		T	T	T		T
default	T	T	T	T		T
private		T	T	T		T
abstract	T		T			T
final	T	T	T			T	T
static		T	T		T	T
strictfp	T		T			T
synchronized			T
native			T
transient		T
volatile		T