Java的面向对象下

Java面向对象下

1.关键字static

1.static可以用来修饰:属性,方法,内部类,代码块
使用static修饰的属性,静态变量
 例子:我们创建了多个对象,每个对象都独立的拥有一个类中的非静态属性,当修改其中一个对象中的非静态属性时,不会导致其它对象中同样的属性值的修改.
 	静态变量,我们创建类的多个对象.多个对象共用一个静态变量,当通过某一对象修改静态变量时,会导致其它对象中的静态变量发生改变.所以static就是静态的,对象共有一个. 
3.可以进行类.属性/方法或者对象.属性/方法来调用.
4.由于类只会加载一次,则静态变量在内存中也只会存在一份,在方法区的静态中.
5.在静态方法中,不能使用this关键字,wuper关键字:因为对象此时还没有创建.

2.设计模式

	总共得设计模式:
		1.创建型模式:共5种:工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式
		2.结构型模式:共7种:适配器模式,装饰器模式,代理模式,外观模式,桥接模式,组合模式,享元模式
		3.行为型模式:共11种:策略模式,模板方法模式,观察者模式,迭代子模式,责任链模式,命令模式,备忘录模式,状态模式,访问者模式,中介模式,解释器模式.

2.1(Singleton)单例的设计模式

	只能创建一个实例,将构造器访问权限设置为private.
	1.饿汉式
		class Sing{
    	private Sing(){
    	}
    	private static Sing s1 = new Sing();
    	public static  Sing getSing(){
    	    return s1;
    	}
		}
	2.懒汉式
		class Order {
    	private Order() {
    	}

    	private static Order s1 = null;
	
    	public static Order getOrder() {
    	    if (s1 == null)
    	        s1 = new Order();
    	    return s1;
    	}
		}
		3.区分饿汉式与懒汉式
			饿汉式:
				好处:饿汉式是线程安全的
				缺点:对象加载时间过长
			懒汉式:
				优点:延迟对象的创建
        缺点:懒汉式是线程不安全的.-->多线程内容时修改.

3.main的理解

	1.main()方法作为程序的入口
	2.main()方法也是一个普通的静态方法.
	main()方法也可以作为与控制台交互的方式.(之前,使用Scanner)

4.代码块(初始化块)

	作用:用来初始化类或者块
	只有两种方式创建
		静态代码块 static {}
			随着类的加载而执行,只会执行一次
			可以定义多个静态代码块
			静态代码块的执行优先于非静态代码块
			静态代码块只能调用静态的属性或方法.不能调用非静态结构
		非静态代码块 {}
			随着对象的创建而执行,可以随着对象而执行多次
			也可以定义多个非静态代码块

5.对属性可以赋值的位置

	执行的顺序:
	① .默认初始化
	②.显示初始化 / ③ 在代码块中赋值
	④ 构造器中初始化
	⑤ 有了对象以后,可以通过"对象.属性"或"对象.方法",进行赋值

6.final关键字=>最终的

	可以用来修饰的结构:类,方法,变量
	final可以修饰一个类:此类不能被其它类所继承
	String类,System类,StringBuffer类
	final 用来修饰方法:表示不能再被子类重写等操作
	final修饰的"变量"称为一个常量.

7.抽象类

abstract :抽象的,抽象性
	可以修饰 类,方法
1.被abstract修饰的类不能被"实例化"
	1.1抽象类中,一定有构造器.子类实例化的时候调用
	1.2都会提供抽象类的子类,让子类实例化,
2.abstract修饰方法
	public abstract void eat();只有方法的声明,没有方法体.
	注:包含抽象方法的类,一定是一个抽象类.反之,一个抽象类不一定有抽象方法的.
	抽象类中有抽象方法,则子类需重写抽象方法,才可以实例化;若没有全部重写抽象方法,则这个子类也是一个抽象类.
3.abstract 不能用来修饰：属性，构造器等结构
4.abstract不能用来修饰私有方法、静态方法、final方法，、final的类

8.抽象类的匿名子类

Person类为抽象类,并且里面有抽象方法
Person p = new Person(){ //创建了一个匿名子类的对象,也是一个多态的使用,为了节省代码
	@Override
	public void eat(){
		sout("--匿名子类")
	}
}

9.接口(interface)

为了从几个类中派生出一个子类,继承它们所有的属性和方法,但是,Java不支持多继承的。有了接口就可以实现多重继承的效果。
1.接口使用interface来定义，
2.Java中接口和类是并列的结构
3.
	3.1JDK7及以前：
		接口中只能够定义全局常量和抽象方法
			全局常量：public static final,书写时可以省略不写。
			抽象方法 public abstract的
		
			interface Flyable{
				public static final int MAX_SPEED = 7900;
				MIN_SPEED =  1;//省略了，但还是有
				public abstract void fly();
				void stop();
			}
	3.2JDK8：还可以定义静态方法和默认方法
4.接口口不能定义构造器，不能实例化。
5.通过让类实现接口(implements)
	interface person{
		public static final int NUM = 10;
		public abstract void fly();
	}

	//类实现
	class Plane implements Person{
		public void fly(){
			sout("a")
		}
	}
5.2接口的作用就是在开发中都是面向接口编程
6.创建接口的匿名实现类的匿名对象
	interface Person{
		void eat();
	}
	System.out.println(new Person(){//实现
	@Override
		public void eat(){
			System.out.println("---");
		}
	});
	

10.接口的应用：代理模式

通过代理类来调用被代理类来实现功能.
interface NetWork{
	public void browse();
}
class Server implements NetWork{//被代理类
	@Override
	public void browse(){
		sout("开始上网");
	}
}
class ProxyServer implements NetWork{//代理类
	private Server serv;
	public ProxyServer(Server serv){
		this.serv = serv;
	}
	@Override
	public void browse(){
			this.check();
			serv.browse();
	}
	public void check(){
		sout("检查工作完成")
	}
}
public class Test{ //测试
	psvm(String[] args){
		Server serv = new Server();
		new ProxyServer(serv).browse();
	}
}

11.接口面试题

1.这道题可以输出嘛?如果可以则输出什么,如果不可以则需要改什么地方可以输出1或2?
interface A{
	int x = 1;
}
class B{
	int x = 2;
}
class C extends B implements A{
	public void pX(){
		sout(x); //出错,因为x并不确定,需要指定x是谁的x
		可以改为:sout(super.x);也可以改为sout(A.x);//因为接口中的属性默认为全局常量,可以通过A.x得到
	}
	psvm(String[] args){
		new C().pX();
	}
}
2.这道题哪些地方出错?
	interface Playable{
		void play();
	}
	interface Bounceable{
		void play();
	}
	interface Rollable extends Playable,Rollable{
		Ball ball = new Ball("Pingpang")
	}
class Ball implements Rollable{
	private Sring name;
	public String name(){
		retuen name;
	}
	public Ball(String name){
		this.name = name;
	}
	public void play(){//这里错误,不知道自己调的哪个play
		ball = new Ball("Football");//这里错误,因为接口中的属性为全局常量,b
		sout(ball.getName())
	}
}

12.JDK8接口的的新特性

1.除了定义全局常量和抽象方法之外,还可以定义静态方法,默认方法.

public interface Compare{
	public static void method1(){
		sout("北京");//接口中定义的静态方法,只能通过接口来调用
	}
	public default void method2(){
		sout("上海");
	}
}
1.接口中定义的静态方法,只能通过接口来调用.
2.通过实现类的对象,可以调用接口的默认方法
3.如果实现类重写了接口的默认方法,则调用的是重写后的方法.
class Person{
	public void eat(){...}
}
interface P{
	default void eat(){...}
}
class Stu extends Person implements P{
	Stu s1 = new Stu();
	s1.eat();//调用的是父类的方法
}
4.上述如果子类(实现类)继承的父类和实现的接口中,声明了同名同参数的默认方法,子类在没有重写此方法的情况下,默认调用父类的方法.
5.如何实现了多个接口,且多个接口中有同名同参数的默认方法那么在实现类没有重写此方法的情况下,报错,-->接口冲突
解决办法必须在实现类中重写此方法.
class Stu implements P,P2{
	Stu s1 = new Stu();
	s1.eat();//报错,因为它不知道调用哪个
}
6.如果你在实现类中重写了默认方法,那怎么再调用接口中的默认方法呢?
	可以通过:=>接口.super.默认方法();的形式去调用接口中的默认方法

13.类的内部成员五：内部类

1.Java中允许将一个类A声明在另一个类B中,则类A就是内部类.B为外部类.
2.内部类的分类:
	成员内部类VS局部内部类(方法,代码块,构造器)
public class Test{
	public void eat(){
		class B{}
	}
	{
		class B{}
	}
	public Test(){
		class B{}
	}
	//成员
	static class B{ //静态的
	
	}
	
	class B{
		public void eat(){
			Test.this.eat();//调用外部类的成员
		}
	}
}
1.成员内部类:
	一方面:作为外部类的成员:
		> 调用外部类的结构
		> 可以被static 修饰
		> 可以被4种不同的权限修饰
	另一方面:作为一个类:
		> 类内部定义属性,方法,构造器
		> 可以被final修饰,表示不可以被继承了,反之可以被继承
		> 可以被abstract修饰
2.注意:
	如何实例化成员内部类的对象?
		public class P{
			class A{}
			static B{}
			psvm(){
				P.B b = new P.b();//静态内部类的实例化
				P.A a = P.new A();//非静态的内部类的实例化
			}
		}
		
	如何在成员内部类种区分调用外部类的结构
		使用外部类.this.xxx来调用
	开发中局部内部类的使用
		public Comparable getCom(){
			class Comparable{
				@Override
				public void eat(){...}
			}
			return new Comparable();
			方式二:
				return new Comparable(){
					@Override
					public void eat(){...}
				}
		}