1.抽象类
概述：
用来描述抽象概念的类，叫做抽象类。抽象类中的方法不一定有具体的实现。
package org.wdit;
public class unit08 {
public static void main(String[] args) {
Pets pets = new Dod();
pets.voice();
pets.eat();
Pets pets1 = new Cat();
pets1.voice();
pets1.eat();
}
}
abstract class Pets{
public abstract void voice();
public abstract void eat();
}
class Dod extends Pets{
@Override
public void voice() {
System.out.println("汪汪叫");
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
class Cat extends Pets{
@Override
public void voice() {
System.out.println("喵喵叫");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
特点：
1.不能直接被创建对象，只能通过子类去创建。
2.抽象类中不一定有抽象方法的类，有抽象方法的类一定是抽象类。
3.被abstract关键字修饰
4.抽象类可以被继承
普通类：其子类必须重写抽象类中的抽象方法
抽象类子类：可以不用重写抽象方法
成员特点：
抽象类成员特点：
成员变量： 可以是变量，也可以是final修饰的变量（常量），静态变量
成员方法 ： 可以是抽象方法，也可以是非抽象方法
构造方法 ： 有构造方法，但是不能被创建对象；其作用是子类访问父类构造方法，对其数据进行初始化时使用
package org.wdit.unit09;
public class AbstractDemo {
}
abstract class Animal{
public int age;
private String name;
public final int num=20;
public void method(){
}
public abstract void method2();
public static void method3(){}
public final void method4(){}
public Animal(){}
}
注意事项：
1.有构造方法，但不能被实例化。用于子类初始化父类数据
2.一个类，如果没有抽象方法，但是被定义成抽象类，其目的是为了不让创建该类对象。
3.abstract与其它关键字的关系：
1.private：冲突关系，因为抽象方法必须被子类重写，而private修饰的方法，不能被继承，从而导致不能被重写。
2.final：冲突，因为被final关键字修饰的方法，不能被重写
3.static：冲突，因为static修饰的方法是随类的加载而加载，可以直接通过类名被调用，没有意义
package org.wdit.unit09;
import java.security.DigestException;
public class AbstractText {
public static void main(String[] args) {
Dog dog = new Dog("老黑",3);
dog.show();
dog.voice();
dog.eat();
dog.sleep();
Cat cat = new Cat("pig",3);
cat.show();
cat.voice();
cat.eat();
cat.sleep();
}
}
abstract class Animal1{
private String name;
private int age;
public abstract void voice();
public abstract void eat();
public Animal1(){
}
public Animal1(String name,int age){
this.name=name;
this.age=age;
}
public void sleep(){
System.out.println("睡觉");
}
public void show(){
System.out.println("名字:"+name+"年龄:"+age);
}
}
class Dog extends Animal1{
public Dog(String name,int age){
super(name, age);
}
@Override
public void voice() {
System.out.println("汪汪叫");
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
class Cat extends Animal1{
public Cat(String name,int age){
super(name, age);
}
public Cat(){}
@Override
public void voice() {
System.out.println("喵喵叫");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
2.接口
概述：
接口是一系列方法声明（方法规范）的集合。一个接口中只有方法的特征，没有方法的实现。因为这些方法可以在不同的类中做不同的实现，而这些实现可以具有不同的结果。
特点：
1.定义关键字：interface
格式： interface 接口{}
2.实现接口关键字：implements
格式：class 类名 implements 接口名{}
3.接口不能被创建对象，但是它可以通过多态去实例化
格式：接口名 变量名 = new 实现类名（）
4.接口的实现类：
a.标准类：重写接口中的抽象方法
b.抽象类：不必重写接口中的抽象方法。交由子类来实现
public class InterfaceDemo {
}
class BiJiComputer implements ComputerExtend{
@Override
public void print() {
System.out.println("打印");
}
public void learn(){
System.out.println("我在学习");
}
public void playGame(){
System.out.println("玩英雄联盟，爽歪歪" );
}
}
abstract class TaiShiComputer implements ComputerExtend{
}
interface ComputerExtend{
public abstract void print();
}
成员特点：
接口的成员特点：
1.成员变量
接口中不能有变量，只能是常量（默认被 public static final修饰）
2.成员方法
只能是抽象方法，并且默认被public abstract修饰
3.构造方法
没有构造方法
package zhaotongit.unit01;
public class InterfaceDemo {
public static void main(String[] args) {
MyInterfaceImpl myInterface = new MyInterfaceImpl();
System.out.println(myInterface.num);
System.out.println(myInterface.num2);
System.out.println(myInterface.num3);
System.out.println(myInterface.num4);
System.out.println(MyInterface.num);
System.out.println(MyInterface.num2);
System.out.println(MyInterface.num3);
System.out.println(MyInterface.num4);
}
}
interface MyInterface{
public int num = 10;
public final int num2=10;
public static int num3=30;
public static final int num4 =40;
public abstract void method();
}
interface MyInterface1{
}
class MyInterfaceImpl extends Object implements MyInterface,MyInterface1{
public MyInterfaceImpl(){
super();
}
@Override
public void method() {
System.out.println("你好");
}
类与接口的关系：
1.类与类
继承关系：单继承或多层继承
2.类与接口
实现关系：单实现或多实现
3.接口与接口
继承关系：单继承或多继承
package zhaotongit.unit01;
public class InterfaceDemo1 {
}
class Father{}
class Mother{}
class Son extends Father{}
class Son1 extends Mother{}
interface Play{}
interface Sing{}
class Phone implements Play{}
class Computer implements Play,Sing{}
interface Sister extends Play{}
interface Boy extends Play,Sing{}
注意：
面试题：java中的继承都是单继承？java中的类都是单继承？
接口和抽象类的区别：
1.组成区别
抽象类;
成员变量：变量与变量
成员方法：可以是抽象方法，也可以是普通方法
构造方法：有构造，但是不能创建对象
接口：
成员变量：常量
成员方法：抽象方法 public abstract
构造方法：没有构造方法
2.关系的区别
类与抽象类：继承–单继承或多层继承
类与接口：实现
抽象类与接口：实现
接口与接口：继承–单继承或多继承
3.引用的区别：
抽象类：定义继承体系中相同属性和方法
接口：类的扩展功能
形式参数是引用类型
1.类：在T调用方法是，传入相应类的对象（匿名对象）
package zhaotongit.unit01;
public class FunctionDemo3 {
public static void main(String[] args) {
TeacherDemo teacherDemo=new TeacherDemo();
Teacher teacher = new Teacher();
teacherDemo.method(teacher);
teacherDemo.method(new Teacher());
}
}
class Teacher{
public void teach(){
System.out.println("教书");
}
}
class TeacherDemo{
public void method(Teacher teacher){
teacher.teach();
}
}
2.抽象类：在方法调用时，传入抽象类的子类对象
3.接口：在方法调用时，传入的是接口的实现类对象
返回值是引用类型
1.类：返回相应类的对象（匿名对象）
package zhaotongit.unit01;
public class FunctionDemo {
public static Student method(){
Student student = new Student("屈波",20);
return student;
}
public static void main(String[] args) {
Student sc =method();
System.out.println(sc);
sc.show();
}
}
class Student{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void show(){
System.out.println(name+"\n"+age);
}
}
2.抽象类：返回抽象类的子类对象
package zhaotongit.unit01;
public class FunctionDemo1 {
public static void main(String[] args) {
Pets pets = new Dog();
Pets pets1 = new Cat();
method(pets);
method(pets1);
Pets pets2 = method1();
System.out.println(pets2);
}
public static void method(Pets pets){
pets.voice();
}
public static Pets method1(){
Pets pets = new Dog();
System.out.println(pets);
return pets;
}
}
abstract class Pets{
abstract void voice();
}
class Dog extends Pets{
@Override
void voice() {
System.out.println("汪汪");
}
}
class Cat extends Pets{
@Override
void voice() {
System.out.println("喵喵喵");
}
}
3.接口：返回接口的实现类对象
package zhaotongit.unit01;
public class FunctionDemo2 {
public static void main(String[] args) {
MyInterface2 myInterface2=new Demo();
function(myInterface2);
System.out.println(method());
}
public static void function(MyInterface2 myInterface2){
myInterface2.method();
}
public static MyInterface2 method(){
MyInterface2 myInterface2=new Demo();
return myInterface2;
}
}
interface MyInterface2{
public abstract void method();
}
class Demo implements MyInterface2{
@Override
public void method() {
System.out.println("你好");
}
}
3.包
概述：
其实就是文件夹
作用:
对类进行分类管理
关键字：package
格式：
package 包名；（多级包用“.”隔开）
注意事项：
1.package语句必须是第一条可执行语句
2.一个java文件中，只能有一条package语句
3.没有package语句，默认就是没有包
导包：
格式：import 包名.类名
import 包名.*
4.权限修饰符
| 权限修饰符 | 本类 | 同包 | 不同包下的子类 | 不同包的其他类 |
|---|
| private | √ | | | |
| 默认 | √ | √ | | |
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
1.常见修饰符
1.权限修饰符：private，默认，protected，public
2.状态修饰符：static ，final
3.抽象修饰符：abstract
常用情景：
1.类
权限修饰符，抽象修饰符，状态修饰符：final
常用：public
2.成员变量
权限修饰符，状态修饰符
常用：private
组合：public final
3.成员方法
权限修饰符，状态修饰符，抽象修饰符
常用：public
组合：public static
public static final
public abstract
public final
4.构造方法
权限修饰符
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
