java | （八）面向对象（4）static、抽象类、接口、内部类、常用方法

static

静态的，用来修饰：属性、方法、代码块、内部类
使用static修饰属性：
静态变量：创建了列的多个对象，多个对象共享一个静态变量，当通过某一个对象修改静态变量，会导致其他对象调用该静态变量，会发生改变。
静态变量随着类的加载而加载，要早于类的对象的创建，由于它只加载一次，因此内存只有一份

package com.atguigu.exer;

public class Student extends Person{
	String major;
	int id = 1001;//学生证号码
	static String c;
	public Student(String major,int id) {
		this.major = major;
		this.id = id;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
	
}

package com.atguigu.exer;

public class Text {
	public static void main(String[] args) {
		Student s1 = new Student("机械", 10098);
		Student s2 = new Student("机械", 10098);
		s1.c = "中国";
		s2.c= "法国";
		System.out.println(s1.c);//法国
	}
}

以上代码解析的内存图如下：

使用static修饰方法
在静态方法中，只能调用静态的方法和属性；在非静态方法中，既可以调用静态方法也可以调用非静态的方法

public class Student extends Person{
	String major;
	int id = 1001;//学生证号码
	static String c;
	public Student(String major,int id) {
		this.major = major;
		this.id = id;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
	
	public static void show() {
		System.out.println("im a " + Student.c);
		walk();
		//不能使用非静态的方法
	}
	
	public static void walk() {
		
	}	
}

开发中如何确定一个属性要用static？
属性可以被多个对象共享，不会随着对象不同而不同

可发中如何去顶一个方法要加static？
操作静态属性的方法，通常设置为static
工具类中的方法习惯上声明为static的，如Maht、Arrays、Collection

单例模式

饿汉式：
坏处：对象加载时间长
好处：线程安全

懒汉式：
好处：延迟对象的创建
坏处：目前写法线程不安全

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

抽象类

修饰结构、类、方法
不能实例化
抽象类中一定有构造器，便于子类实例化调用（涉及：子类对象调用的全过程）
开发中都会提供抽象类的子类，让子类对象实例化
包含抽象方法的类，一定是一个抽象类

抽象方法只有方法的声明，没有方法体；
包含抽象方法的类，一定是一个抽象类，而抽象类可以没有抽象方法
若子类重写了父类中的所有抽象方法，此子类方可实例化，若没有，则子类也是一个抽象类，要用abstract修饰
抽象类不能修饰私有方法、静态方法、final方法、final的类

package com.atguigu.java4;

public class AbstractTest {

}

abstract class Person{
	String name;
	int id;
	public Person() {
		
	}
	
	public abstract void eat();//抽象方法
}

class Student extends Person{
	public Student(String name,int id) {
		this.name = name;
		this.id = id;
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("eat");
	}
}

匿名类

package com.atguigu.exer;

public class Text {
	public static void main(String[] args) {
		method(new Student());//匿名对象
		
		Worker worker = new Worker();
		method1(worker);//非匿名类非匿名对象
		
		method1(new Worker());//非匿名的类匿名对象
		
		//创造了一个匿名子类对象：p
		Person p = new Person() {
			@Override
			public void eat() {
				// TODO Auto-generated method stub
				System.out.println("吃东西");
			}
		};
		method1(p);
		
		
		//创造匿名子类匿名对象
		method1(new Person() {
			@Override
			public void eat() {
				// TODO Auto-generated method stub
				System.out.println("?????");
			}
		});
	}
	
	public static void method(Student s) {
		
	}
	
	public static void method1(Person p) {
		p.eat();
	}
}


class Worker extends Person{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("worker is eating");
	}
	
	
}

例题

package lianxiti1;

abstract public class Employee {
	private String name;
	private int  number;
	private MyData birthday;
	
	public abstract double earning() ;

	public Employee(String name, int number, MyData birthday) {
		super();
		this.name = name;
		this.number = number;
		this.birthday = birthday;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "name:" + name + ",number:" + number + ",birthday:" + birthday.toDataString();
	}
	
}

package lianxiti1;

public class MyData {
	private int year;
	private int month;
	private int day;
	
	public String toDataString() {
		return year + "年" + month + "月" + day + "日";
	}

	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public int getDay() {
		return day;
	}

	public void setDay(int day) {
		this.day = day;
	}

	public MyData(int year, int month, int day) {
		super();
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	
}

package lianxiti1;

abstract public class Employee {
	private String name;
	private int  number;
	private MyData birthday;
	
	public abstract double earning() ;

	public Employee(String name, int number, MyData birthday) {
		super();
		this.name = name;
		this.number = number;
		this.birthday = birthday;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "name:" + name + ",number:" + number + ",birthday:" + birthday.toDataString();
	}
	
}

package lianxiti1;

public class HourlyEmployee extends Employee{
	private int wage;//每小时工资
	private int hour;//月工作的小时数
	public HourlyEmployee(String name, int number, MyData birthday) {
		super(name, number, birthday);
		// TODO Auto-generated constructor stub
	}

	public HourlyEmployee(String name, int number, MyData birthday, int wage, int hour) {
		super(name, number, birthday);
		this.wage = wage;
		this.hour = hour;
	}

	public int getWage() {
		return wage;
	}

	public void setWage(int wage) {
		this.wage = wage;
	}

	public int getHour() {
		return hour;
	}

	public void setHour(int hour) {
		this.hour = hour;
	}

	@Override
	public double earning() {
		// TODO Auto-generated method stub
		return wage * hour;
	}
	
	public String toString() {
		return "SalariedEmployee[" + super.toString() + "]";
	}
	
}

package lianxiti1;

public class SalariedEmployee extends Employee{
	
	private double monthlySalary;
	public SalariedEmployee(String name, int number, MyData birthday) {
		super(name, number, birthday);
		// TODO Auto-generated constructor stub
	}

	@Override
	public double earning() {
		// TODO Auto-generated method stub
		return 1;
	}
	

	public SalariedEmployee(String name, int number, MyData birthday, double monthlySalary) {
		super(name, number, birthday);
		this.monthlySalary = monthlySalary;
	}

	public double getMonthlySalary() {
		return monthlySalary;
	}

	public void setMonthlySalary(double monthlySalary) {
		this.monthlySalary = monthlySalary;
	}
	
	public String toString() {
		return "SalariedEmployee[" + super.toString() + "]";
	}

}

package lianxiti1;

public class PayrollSystem {
	public static void main(String[] args) {
		Employee[] emps = new Employee[2];
		
		emps[0] = new SalariedEmployee("mark", 123, new MyData(1998, 12, 3),12345);
		emps[1] = new HourlyEmployee("jack", 555, new MyData(1991, 4, 5),2450,45);
		
		for(int i = 0;i < emps.length;i++) {
			System.out.println(emps[i]);
			
			double salary = emps[i].earning();
			System.out.println(salary);
		}
	}
}

结果：

接口

interface
接口和类是两个并列的结构

JDK 7前：只能定义全局常量和抽象方法
全局常量：public static final但是可以省略
接口不能定义构造器，意味着接口不可以实例化

java开发中，接口都通过类去实现（implements)
如果实现类覆盖了接口中的所有抽象方法，则此类可实例化；如果没有覆盖接口所有抽象方法，则此类仍为一个抽象类

一个类可以使用多个接口
格式：class AA extends BB implements CC,DD,EE

接口与接口之间也是继承

抽象方法:public abstract

JDK 8:还可以定义静态方法、默认方法（略）

package jdjl;

public class InterfaceTest {

}


interface Flyable{
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
}

interface Attackable{
	void fight();
}

class Plane implements Flyable{

	@Override
	public void fly() {
		System.out.println("通过引擎起飞");
		
	}

	@Override
	public void stop() {
		System.out.println("飞行刹车！");
		
	}
	
}

abstract class Kite implements Flyable{
	@Override
	public void fly() {
		System.out.println("风筝飞");
		
	}
}

class Bullet implements Flyable,Attackable{

	@Override
	public void fight() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		
	}
	
}

接口的规范
接口使用上也满足多态性
接口，实际上就是定义了规范

package jdjl;

public class InterfaceTest2 {
	public static void main(String[] args) {
		//创建了接口的非匿名实现类的非匿名对象
		Computer computer = new Computer();
		Flash flash = new Flash();
		computer.transferData(flash);
		
		//创建了接口的非匿名实现类的匿名对象
		computer.transferData(new Printer());
		
		//创建了接口的匿名实现类的非匿名对象
		USB phone = new USB() {
			
			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
			
			@Override
			public void start() {
				System.out.println("手机开始工作");
				
			}
		};
		computer.transferData(phone);
		
		//创建了接口匿名实现类的匿名对象
		computer.transferData(new USB() {
			
			@Override
			public void stop() {
				System.out.println("mp3结束工作");
				
			}
			
			@Override
			public void start() {
				System.out.println("MP3开始工作");
				
			}
		});
	}
}

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

interface USB{
	void start();
	
	void stop();
}

class Flash implements USB{

	@Override
	public void start() {
		// TODO Auto-generated method stub
		System.out.println("U盘开始工作");
		
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		System.out.println("U盘停止工作");
	}
	
}

class Printer implements USB{

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

	@Override
	public void stop() {
		System.out.println("打印机停止");
		
	}
	
}

结果

接口的应用：代理模式

package com.javvva;

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() {
		// TODO Auto-generated method stub
		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() {
		// TODO Auto-generated method stub
		check();
		work.browse();
	}
}

结果


例题

package jdjl;
//父类
public class Circle {
	private double radius;

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}
	
	public Circle() {
		
	}

	public Circle(double radius) {
		super();
		this.radius = radius;
	}
	
	
}

package jdjl;
//接口
public interface CompareObject {
	//若返回值为0，相等；为正数，代表当前对象大，为负数，当前对象小
	public int compareTo(Object o);
	
}

package jdjl;
public class CompareCircle extends Circle implements CompareObject{

	public CompareCircle(double d) {
		// TODO Auto-generated constructor stub
		this.setRadius(d);
	}

	@Override
	public int compareTo(Object o) {
		if(this == o) {
			return 0;
		}
		
		if(o instanceof CompareCircle) {
			CompareCircle c = (CompareCircle)o;
			return this.getRadius() > c.getRadius() ? 1 : this.getRadius() == c.getRadius() ? 0 : -1;
		}else{
			throw new RuntimeException("传入的数据类型不匹配");
		}
		
		
	}

}

package jdjl;
public class CompareTest {
	public static void main(String[] args) {
		CompareCircle c1 = new CompareCircle(6.7);
		CompareCircle c2 = new CompareCircle(4.5);
		int result = c1.compareTo(c2);
		System.out.println(result);//1
		
		c1.setRadius(3);
		System.out.println(c1.compareTo(new CompareCircle(5.4)));//-1
	}
}

抽象类和接口的区别：
同：不能实例化，都能被继承
异：抽象类：有构造器；接口：无构造器；单继承与多继承区别

java 8：接口新特性

package com.atugiu.java8;

public interface CompareA {
	//静态方法
	public static void mehtod1() {
		System.out.println("compareA:风城");
	}
	//默认方法
	public default void method2() {
		System.out.println("compareA:广州");
	}
	
	default void method3() {
		System.out.println("compareA:俄罗斯");
	}
}

package com.atugiu.java8;

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

package com.atugiu.java8;

public class SubClassTest {
	public static void main(String[] args) {
		SubClass s = new SubClass();
		//s.method1();  //报错。
		//1、接口中定义的静态方法，只能通过接口来调用
		CompareA.mehtod1();//compareA:风城
		//2、通过实现类的对象，可以调用接口中的默认方法
		//如果实现类重写了接口的默认方法，调用时，仍然调用的时重写以后的方法
		s.method2();//compareA:广州
		
		//3、如果实现类（或子类）继承的父类和实现类的接口声明了同名同参数的方法，
		//那么子类在没有重写此方法的情况下，默认调用的是父类父类中同名同参数的方法（类优先原则）
		s.method3();//SuperClass:北京
		
		//4、如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
		//那么实现类没有重写该方法时，会报错！
	}
}

class SubClass extends SuperClass implements CompareA{
}

内部类

成员内部类：
内部类，作为外部类成员，能调用外部类的结构，可static修饰，可以被四种权限修饰
内部类中可以定义属性和方法构造器，可以final修饰（表不能继承），可被abstract修饰

package InnerClassTest;


public class InnerClassTests {
	public static void main(String[] args) {
		//非静态内部类的使用
		Person p = new Person();
		Person.Dog dog = p.new Dog();
		dog.walk();//???
		
		//静态内部类的使用
		Person.Cat cat = new Person.Cat();
		cat.walk();//walking
		
	}
}


class Person{
	String name;
	int age;
	void eat() {
		System.out.println("？？？");
	}
	//成员内部类
	class Dog{
		String name;
		public void walk() {
			Person.this.eat();
		}
	}
	
	//静态内部类
	static class Cat{
		public void walk() {
			System.out.println("walking");
		}
	}
}

内部类调用外部类的方式

package InnerClass.java;
public class InnerClassTest {
	public static void main(String[] args) {
		Apple a = new Apple();
		a.name = "apple";
		Apple.Peat peat = a.new Peat();
		peat.name = "peats";
		peat.show();
		
		Apple.age = 9;
		peat.print();
		
		System.out.println(".............................!");
		Apple.刀 dao = new Apple.刀();
		dao.name = "十八菜籽";
		
		dao.show(a);
	}
	
	

}

class Apple{
	String name;
	static int age;
	
	void show() {
		System.out.println("调用了apple类中的一个非静态方法啊");
	}
	
	static void print() {
		System.out.println("调用了apple类中的一个静态方法");
	}
	
	//内部类
	class Peat{
		String name;
		int age;
		
		public void show() {
			System.out.println(this.name);
			System.out.println(Apple.this.name);
			/*
			Apple apple = new Apple();
			apple.show();
			*/
			Apple.this.show();
		}
		
		public void print() {
			System.out.println(Apple.age);
			Apple.print();
		}
	}
	
	//静态成员内部类：
	static class 刀{
		String name;
		int age;
		public void show(Apple a) {
			System.out.println(this.name);
			
			System.out.println(a.name);
		}
	}
}

结果：
peats
apple
调用了apple类中的一个非静态方法啊
9
调用了apple类中的一个静态方法
…!
十八菜籽
apple