1. 接口，使用interface关键字来定义* 2. 接口，是与类并列的结构* * 3. jdk7及之前：接口中只能定义全局常量（public static final）和抽象方法（public abstract）。* 常量的public static final可以省略* 抽象方法的public abstract也可以省略* * jdk8中： 接口中还可以定义静态(static)方法和默认(default)方法.* jdk9中：接口中还可以定义私有(private)方法* * 明确：接口中没有构造器！接口不可以实例化* * 4. 类与接口之间是实现关系：implements* 类实现接口以后，如果实现了接口中的所有的抽象方法，则此类不是抽象类，可以实例化* 如果实现类没有实现接口中的所有的抽象方法的话，则此类就是一个抽象类，不能实例化。 * 5. 类可以实现多个接口。比如：class Bullet extends Object implements Flyable,Attackable* * 6. 接口与接口之间是继承关系。而且是可以多继承的！
public class InterfaceTest {public static void main(String[] args) {System.out.println(Flyable.MAX_SPEED);
// Flyable.MAX_SPEED = 4500;Plane p = new Plane();p.fly();Flyable f = p;//体现了接口的多态性method(p);}public static void method(Flyable f){f.fly();}
}interface Flyable{ //可以飞的接口//常量public static final int MIN_SPEED = 1;int MAX_SPEED = 7900;//第一宇宙速度//抽象方法public abstract void fly();void stop();
}interface Attackable{ void attack();
}class Plane implements Flyable{//Plane has a Flyable@Overridepublic void fly() {System.out.println("飞行员启动飞机飞行");}@Overridepublic void stop() {System.out.println("飞行员控制飞机停止飞行");} }abstract class Kite implements Flyable{ //Kite has a Flyable}class Bullet implements Flyable,Attackable,C{@Overridepublic void attack() {// TODO Auto-generated method stub}@Overridepublic void fly() {// TODO Auto-generated method stub}@Overridepublic void stop() {// TODO Auto-generated method stub}@Overridepublic void test1() {// TODO Auto-generated method stub}@Overridepublic void test2() {// TODO Auto-generated method stub}}//*************************************
interface A{void test1();
}interface B{void test2();
}interface C extends A,B{//接口的多继承}
class Computer{public void transferData(USB usb){ //USB usb = new Flash();usb.start();System.out.println("usb设备开始进行数据的传输....");usb.stop();}
}interface USB{//常量：尺寸（略）//抽象方法public abstract void start();void stop();}class Flash implements USB{@Overridepublic void start() {System.out.println("U盘开始工作");}@Overridepublic void stop() {System.out.println("U盘结束工作");}}class Printer implements USB{@Overridepublic void start() {System.out.println("打印机开始工作");}@Overridepublic void stop() {System.out.println("打印机结束工作");}}
public class USBTest {public static void main(String[] args) {Computer c1 = new Computer();//1. 创建接口实现类的非匿名对象Flash flash = new Flash();c1.transferData(flash);}
}
public class USBTest {public static void main(String[] args) {Computer c1 = new Computer();//1. 创建接口实现类的非匿名对象Flash flash = new Flash();c1.transferData(flash);//2. 创建接口实现类的匿名对象c1.transferData(new Printer());//3. 创建接口匿名实现类的非匿名对象USB usb1 = new USB(){@Overridepublic void start() {System.out.println("mp3开始工作");}@Overridepublic void stop() {System.out.println("mp3结束工作");}};c1.transferData(usb1);//4. 创建接口匿名实现类的匿名对象c1.transferData(new USB(){@Overridepublic void start() {System.out.println("手机开始工作");}@Overridepublic void stop() {System.out.println("手机结束工作");}});}
}
类似的：抽象类也有同样的使用
public class AbstractTest {public static void main(String[] args) {Student s1 = new Student();//创建了抽象类的匿名子类的对象Person p1 = new Person(){@Overridepublic void eat() {System.out.println("工人多吃肉！");}};// Person p2 = new Person(){};}
}abstract class Person{public abstract void eat();public void sleep(){System.out.println("人睡觉");}
}class Student extends Person{@Overridepublic void eat() {}}
//从java8开始，可以在接口中定义静态方法和默认方法。
public interface CompareA {public static void method1(){System.out.println("CompareA:北京");}public default void method2(){System.out.println("CompareA:上海");}//如下的方法也是public，只是省略了default void method3(){System.out.println("CompareA:深圳 ");}default void method4(){System.out.println("CompareA:广州 ");}
}
public interface CompareB {default void method3(){System.out.println("CompareB:深圳 ");}
}public class SuperClass {public void method4(){System.out.println("SuperClass:广州");}
}
public class SubClass extends SuperClass implements CompareA,CompareB{//重写了接口中的method2()方法public void method2(){System.out.println("SubClass:上海");}public void method3(){System.out.println("SubClass:深圳 ");}public void method4(){System.out.println("SubClass:广州");}public void method(){method4();//调用本类重写的方法hod4();//调用父类中被重写的方法hod3();//调用接口CompareA中的method3()hod3();//调用接口CompareB中的method3()}
}public class InterfaceTest {public static void main(String[] args) {//知识点1：通过接口调用其内部的静态方法。但是实现类不可以调用其静态方法hod1();
// hod1();//知识点2：通过实现类的对象调用接口中的默认方法SubClass sub = new SubClass();hod3();//知识点3：如果实现类重写了接口中的默认方法，则实现类对象调用的就是重写以后的方法hod2();//知识点4：如果实现类实现了两个以上的接口。而至少有两个接口中定义了同名同参数的默认方法，则实现类//必须重写此方法。否则，报异常--->接口冲突//知识点5：如果子类（或实现类）继承的父类和实现的接口中定义了同名同参数的方法，则不会报冲突问题//在子类（或实现类）没重写此方法的情况下，默认调用的是父类中的方法。--->类优先原则hod4();System.out.println();//知识点6：如何在实现类中调用接口的被重写的默认方法hod();}}
1. 理解：我们可以在一个类A的内部定义另一个类B，则此时类B就称为类A的内部类，类A就称为类B的外部类* * 2. 内部类的分类：成员内部类 (静态的、非静态的) vs 局部内部类(方法内、代码块内、构造器内)* * 3. 成员内部类的理解：* 3.1 成员内部类作为一个类：* > 内部可以定义属性、方法、构造器、代码块、内部类* > 可以被abstract修饰，表示不能实例化* > 可以被final修饰，表示不能被继承* * 3.2 成员内部类作为外部类的成员：* > 可以被4种权限修饰符修饰* > 可以被static修饰* > 可以调用外部类的结构（主要是属性、方法）4. 关于内部类需要掌握的三个方面：* > 如何创建静态的和非静态的成员内部类的对象* > 如何在内部类中调用外部类的成员* > 局部内部类在开发中的体现
* > 如何创建静态的和非静态的成员内部类的对象* > 如何在内部类中调用外部类的成员
class Person{String name = "mmm";int age;//成员内部类static class Dog{public void shout(){System.out.println("汪~汪~");}}class Bird{String name = "麻雀";public void show(String name){System.out.println(name);//黄鹂System.out.println(this.name);//麻雀System.out.println(Person.this.name);//mmm}public void sing(){System.out.println("鸟儿在歌唱");eat();System.out.println(age);//Person.this.age}}public void show(){System.out.println("name : " +name + ", age : " + age);}public void eat(){System.out.println("人吃饭");}}
public class OuterClass {public static void main(String[] args) {//创建静态的成员内部类的对象Person.Dog dog = new Person.Dog();dog.shout();//创建非静态的成员内部类的对象Person p1 = new Person();p1.age = 12;Person.Bird bird = p1.new Bird();bird.sing();bird.show("黄鹂");}
}
//局部内部类在开发中的体现
public class OuterClass1 {public void method(){//局部内部类//此种情况在开发中很少见class A{}}//返回接口实现类的对象public Comparable getComparable(){//方式一：声明一个接口的实现类
// class MyComparable implements Comparable{
//
// @Override
// public int compareTo(Object o) {
// return 0;
// }
//
// }
// return new MyComparable();//方式二：创建接口的匿名实现类的匿名对象return new Comparable(){@Overridepublic int compareTo(Object o) {return 0;}};/** * button.setOnClick(new ClickListener(){* public void onClick(){* //当点击按钮时，希望触发的操作* }* });* * * */}}
对应的类为：
class Person{String name = "mmm";int age;//成员内部类static class Dog{public void shout(){System.out.println("汪~汪~");}}class Bird{String name = "麻雀";public void show(String name){System.out.println(name);//黄鹂System.out.println(this.name);//麻雀System.out.println(Person.this.name);//mmm}public void sing(){System.out.println("鸟儿在歌唱");eat();System.out.println(age);//Person.this.age}}public void show(){System.out.println("name : " +name + ", age : " + age);}public void eat(){System.out.println("人吃饭");}//********************************public void method(){//局部内部类class A{}}{//局部内部类class A{}}public Person(){//局部内部类class C{}}}
类与对象的理解和关系
面向对象编程的思路：
声明：针对于工具类等结构，通常内部都是定义静态的属性或方法，直接通过类进行调用。
主线一：类的内部结构
主线二 ：面向对象的三大特征
主线三：关键字的使用
this
import
package
super
static
final
abstract
interface
属性
方法（最重要）
构造器
代码块
内部类
主线二 ：面向对象的三大特征
主线三：关键字的使用
this
import
package
super
static
final
abstract
interface
如果这些对你有帮助的话，可不可以帮我一键三连呢？
本文发布于:2024-02-01 04:01:01，感谢您对本站的认可！
本文链接：https://www.4u4v.net/it/170673126333703.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
| 留言与评论（共有 0 条评论） |
