修饰符

public：修饰类、方法、最大的权限权限，在任何地方都可以被使用、成员变量
protected：受保护的权限只能在子类中访问，可以修饰方法和成员变量
默认就是什么都不写，可以修饰，类、方法、成员变量
private：权限修饰符，私有访问，修饰方法，成员变量
static ：静态修饰符，可以修饰方法，成员变量，
final：类（不能被继承）、方法（不能被子类重写）、（变量赋值后不能改）成员变量、局部变量
abstract：抽象修饰符，可以修饰类（需要被子类继承重写方法）、修饰符，

方法不能混用

abstract和private，
abstract和static，abstract和final也不可一起用

成员变量修饰符

public：公共变量； protected：受保护的
：默认修饰符 private：私有的
final：最终的，变量值不可变 static：静态的

抽象类abstract

package Chouxiang;
/*
 * 定义开发工程师
 * EE开发
 * Android工程师
 * 根据共性进行抽取，形成父类、
 * 定义父类方法job，怎么工作，具体干什么？那个岗位的？
 * 抽象类，不能实例化对象，就是不能new抽象类。
 * 不能创建对象的原因是：如果让你new了，对象调用抽象方法，抽象方法没有主体所以根本就不运行
 * 抽象类使用方式：定义类继承抽象类，将抽象方法进行重写，创建子类的对象
 */
public abstract class Develop {
	//定义方法，工作方法，说不清讲不明白,这种方法叫没有主题的方法，
	//抽象方法，必须存在于抽象的类中，类也必须加abstract修饰成抽象方法
	public abstract void work();
	
}
//定义Javaee的开发人员
//继承develop方法，重写抽象方法
class JavaEE extends Develop{
	//重写父类的抽象方法
	//去掉abstract修饰符，加上方法主体
	public void work() {
		System.out.println("javaee在开发sb软件");
	}
}
//创建Android类，工作类重写方法
class Android extends Develop{
	public void work(){
		System.out.println("安卓在开发手机软甲");
		
	}
	{
}
	
}
//测试抽象类：创建子类的对象，再用子类对象调用方法
class Test{
	public static void main(String[] args) {
		JavaEE ee=new JavaEE();
		ee.work();
		Android and=new Android();
		and.work();
		
	}
}

抽象方法特点：

抽象方法和抽象类都需要被abstract所修饰，抽象方法一定要定义在抽象类中
抽象类不可以直接创建对象，原因：调用抽象方法没有意义
只有覆盖了抽象类的所有方法才能后，子类才能创建对象，否则该子类因为继承了父类的抽象方法，所以子类还是抽象的类，所以这类依然不能创建对象就是不能new
之所以继承抽象，重要的是思想

抽象类的作用

抽象类将强制重写抽象的方法，比如，你想加入丐帮，就必须去要饭
抽象类一定是一个父类，抽象类可以没有抽象方法，可以定义带有方法体的方法，就是可以让子类继承以后直接用，

接口

接口是功能的集合，可以理解成比抽象类还抽象的类，接口里全是抽象方法，只能铐靠子类完成

定义接口

* 使用关键字interface，接口名字
* 成员方法，全是抽象方法，，不能有方法体的方法

类实现接口

类与接口之间叫实现，与继承相似使用implements//
定义类，实现接口，重写接口中的抽象方法，可以理解成继承
定义规范：class 类名 implements 接口{}

package JieKou;

/*
 * 定义一个类，实现接口的方法，重写接口中的抽象方法
 * 创建实现类的对象
 * 
 * 类实现接口 ，可以理解为继承（但是也有区别
 * 
 * 关键字implements：定义类，实现接口
 * class 类 implements 接口{
 * 		重写接口中的所有抽象方法
 * }
 */
public interface MyInterface {
	// 在接口中定义抽象方法
	public abstract void function();

	// 在接口中，定义抽象的方法
	public static final int a = 1;

}
//定义类，实现接口，重写接口中的抽象方法，可以理解成继承
//定义规范：class 类名  implements 接口{}
//			类				实现			接口
//		MyInterfaceImpl implements MyInterface
//		实现类的工作是，重写接口中的方法
class MyInterfaceImpl implements MyInterface{
		public void function() {
			System.out.println("实现类，重写接口抽象方法");
		}
}

class Tese {
	public static void main(String[] args) {
		//创建接口的实现类的对象
		MyInterfaceImpl my = new MyInterfaceImpl();
		my.function();
	}
}

接口中成员的特点

成员变量的特点，没有变量，都是常量：
public static final 数据类型变量名=值
三个修饰符可以选测性书写，但是最好还是写上

* 定义抽象方法

* public abstract 返回值类型方法名字（参数列表）
* 在接口里的方法均为公共分享的方法，，
* 关于接口的修饰符，写与不写都是public，其他的都不行
子类必须覆盖掉接口的所有抽象方法后，才能创建子类的对象能够实例化，否则子类还是一个抽象类

package JieKou;

public interface MyInter {
	public static final int x = 3;
	public abstract void show();
	public abstract int getSum(int a, int b);
}

class MyInterImpl implements MyInter {
	// 重写接口中的抽象方法，权限public是必须写
	public void show() {
	}
	public int getSum(int a, int b) {
		return 0;
	}
}

class Test {
	public static void main(String[] args) {
		// 使用接口定义的常量，由于常量被静态修饰。可以被类名.直接调用，被接口名直接调用
		System.out.println(MyInter.x);
		// 错误：MyInter.x=3; final定义的量不可以赋值
	}
}

接口的多实现

和继承不一样，继承只能单一继承，接口可以多实现
多实现没有安全隐患，原因在于接口中的方法全是抽象方法，所以抽象方法的实现需要实现类去实现
多实现接口的时候，public class C implements A，B{}
注意C需要重写AB的所有的抽象方法

类继承类的同时多实现

在继承的时候可以多实现接口
public class C extends D implements A，B{}
接口与接口之间是继承关系，类与类之间是继承关系，类与接口之间是实现关系

接口和抽象类

相同点

都位于继承的顶端，用于被其他类继承或者实现
都不能实例化对象new（）
都包含抽象方法，其子类都必须都要覆写这些抽象方法

不同点

抽象类部分方法（普通方法）可以不用实现，避免子类重复实现这些方法，提高代码的复用性，
而接口是实现类必须要实现接口中所有的抽象方法
抽象类是事物中应该具备的内容
接口是事物中额外的内容

选用的时候多选用接口，少选用抽象类
需要定义子类的行为，又要为子类提供共性功能选用抽象类

多态

多态的调用方法中，方法必须运行子类的重写

普通类调用多态

public class Fu {

	public void show() {
		System.out.println("父类的方法");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("子类的方法");
	}
}

class Test{
	//java中，对象的多态性，调用程序中的方法
	//公式：父类类型或者接口类型    变量  =  new  子类对象();
	public static void main(String[] args) {
		Fu f = new Zi();
		f.show();
	}
	
}

抽象类，子类继承实现多态

public abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃猫粮");
	}
}
class Test{
	public static void main(String[] args) {
		//抽象类时Animal，子类时Cat
		Animal a= new Cat();
		a.eat();
	}
}

接口调用多态性

public interface Smoking{
	public abstract void somking();
}
public class Student implements Smoking{
	public void somking() {
		
		System.out.println("学生在吸烟");
	}
	
}
class Test{
	//接口Smoking，实现类Student进行多态类的编写
	public static void main(String[] args) {
		Smoking sk=new Student();
				sk.somking();
	}
	
}

多态，成员特点
成员变量

编译时，参考父类中有没有这个变量，如果有，编译成功，没有编译失败
运行时，运行的是父类中的变量值

成员方法

编译时，参考父类中有没有这个方法，有这个方法编译成功，没有编译失败
运行时，运行的是子类重写后的方法

修饰符、抽象类、接口、多态

修饰符

方法不能混用

成员变量修饰符

抽象类abstract

接口

接口和抽象类

多态

多态，成员特点

猜你喜欢