instance of
package com.oop.demo06;
?
public class Teacher extends Person{
?
}
package com.oop.demo06;
?
public class Person {
? public void run(){
? ? ? System.out.println("run");
? }
}
package com.oop.demo06;
?
public class Studenr2 extends Person{
? public void go(){
? ? ? System.out.println("go");
? }
}
/*测试
//Object>String
? ? ? //Object>Person>Teacher
? ? ? //Object>Person>Student2
? ? ? //System.out.println(x instanceof y);判断x与y是否存在父子关系 左边类名级别决定能跟哪一级编译判断，不能和并列级判断
? ? ? Object studenr1 = new Studenr2();
? ? ? System.out.println(studenr1 instanceof Studenr2);
? ? ? System.out.println(studenr1 instanceof com.oop.demo06.Person);
? ? ? System.out.println(studenr1 instanceof Object);//true
? ? ? System.out.println(studenr1 instanceof com.oop.demo06.Teacher);//false
? ? ? System.out.println(studenr1 instanceof String);
? ? ? System.out.println("===============================================");
? ? ? com.oop.demo06.Person person1 = new Studenr2();
? ? ? System.out.println(person1 instanceof Studenr2);
? ? ? System.out.println(person1 instanceof com.oop.demo06.Person);
? ? ? System.out.println(person1 instanceof Object);//true
? ? ? System.out.println(person1 instanceof com.oop.demo06.Teacher);//false
? ? ? //System.out.println(person1 instanceof String); 编译就报错
? ? ? System.out.println("===============================================");
? ? ? com.oop.demo06.Studenr2 student2 = new com.oop.demo06.Studenr2();
? ? ? System.out.println(student2 instanceof Studenr2);
? ? ? System.out.println(student2 instanceof com.oop.demo06.Person);
? ? ? System.out.println(student2 instanceof Object);//true
? ? ? //System.out.println(student2 instanceof com.oop.demo06.Teacher);//编译就报错
? ? ? //System.out.println(student2 instanceof String); //编译就报错
?
? ? ? //类型之间转化：基本类型 高低64 32 16 8 / 父 子
? ? ? //将person1这个对象转化为Studenr2类型，就可以使用Studenr2的方法了，高转低要强转
? ? ? //子类转化为父类，可能丢失一些方法
? ? ? ((Studenr2) person1).go();
*/
/*
1.父类引用指向子类对象，反之不行
2.子类转为父类，不用强转，会丢失方法
3.父类转为子类，要强转
4.方便方法调用，减少重复代码，不用再重新new一个类，把原来的降级或升级可以调用其他方法
面向对象特征：封装、继承、多态 都是为了抽象（编程思想）
*/
static 关键字详解
package com.oop.demo07;
//static
public class Student {
? private static int age;//静态变量，能被多个类共享，多线程
? private double score;//非静态变量
?
? public void run(){//非静态方法可调用静态方法所有东西
? ? ? go();
? }
? public static void go(){
?
? }
?
? public static void main(String[] args) {
? ? ? Student s1 = new Student();
? ? ? System.out.println(Student.age);//类变量（静态变量推荐用类名.变量，非静态变量（score）不能这样访问）
? ? ? System.out.println(s1.age);//对象调用变量
? ? ? System.out.println(s1.score);
?
? ? ? new Student().run();//静态方法可调用静态方法，不能调用普通方法（静态与类一起加载，加载之前没有普通类），需要new
? ? ? Student.go();//go();
?
?
? }
?
}
package com.oop.demo07;
?
public class Person {
? {
? ? ? //2.代码块（匿名代码块）构造器之前，用来赋初始值
? ? ? System.out.println("匿名代码块");
? }
? static{
? ? ? //1.静态代码块，加载初始化数据，与类一起加载，只执行一次
? ? ? System.out.println("静态代码块");
? }
?
? public Person() {//3.构造器
? ? ? System.out.println("构造方法");
? }
?
? public static void main(String[] args) {
? ? ? Person person1 = new Person();//调用非静态加new
? ? ? System.out.println("===================");
? ? ? Person person2 = new Person();//static只执行一次
?
? }
}
package com.oop.demo07;
?
import static java.lang.Math.random;//静态导入包
import static java.lang.Math.PI;
public class Test {
? public static void main(String[] args) {
? ? ? System.out.println(random());
? ? ? System.out.println(PI);
? }
}
//final修饰类 无父子关系
抽象类
package com.oop.demo08;
//抽象类 本质是类需要继承 extend：单继承 （接口可以多继承）
public abstract class Action {
? //只有约束~不写方法体，有人帮我们实现
? public abstract void doSomething();//抽象方法，只有方法名，没有方法实现
?
?
}
/*抽象类
1.不能new，只能靠子类实现
2.抽象类可以写普通方法，可以写抽象方法，但有了抽象方法必包含于抽象类
3.抽象的抽象：约束
思考题
1.存在构造器吗，存在
2.存在的意义是什么 抽象共有属性，重写方法，提高开发效率，可扩展性
*/
package com.oop.demo08;
//抽象类的所有方法必须要由子类实现，除非子类也抽象，需要子子类实现
public class A extends Action{
?
? @Override
? public void doSomething() {
?
? }
}
接口的定义与实现
package com.oop.demo09;
//锻炼抽象思维
//接口 interface定义关键词 接口都需要实现类
public interface UserService{
? //接口中所有定义的方法都是抽象的 简写 返回值类型+方法名
? void run(String name);//public abstract void run();
? void delete(String name);
? void update(String name);
? void query(String name);
? //接口中所有定义的属性都是常量 public static final
? int AGE=99;
? ?
? ?
}
package com.oop.demo09;
?
public interface TimeService {
? void timer();
?
}
package com.oop.demo09;
//类可以实现接口 implements接口（多个） extends抽象类（单继承）
//实现接口，需要重写接口中方法
public class UserServiceImpl implements UserService,TimeService{//alt+回车
?
? @Override
? public void run(String name) {
?
? }
?
? @Override
? public void delete(String name) {
?
? }
?
? @Override
? public void update(String name) {
?
? }
?
? @Override
? public void query(String name) {
?
? }
?
? @Override
? public void timer() {//多继承
?
? }
}
接口的作用：
1.约束
2.定义一些方法，让不同的人实现
3.方法都是 public abstract
4.常量都是 public static final
5.接口不能被实例化，接口中没有构造方法（接口不是类，不能new）
6.implements可实现多个接口
7.必须要重写接口中方法
N中内部类
成员内部类、静态内部类、局部内部类、匿名内部类
package com.oop.demo10;
?
public class Outer {
?
? private int id=10;
? public void out(){
? ? ? System.out.println("这是外部类的方法");
? }
? public class Inner{//加static变静态内部类，与类一起加载
? ? ? public void in(){
? ? ? ? ? System.out.println("这是内部类的方法");
? ? ? }
? ? ? //内部类获得外部类的私有属性
? ? ? public void ID(){
? ? ? ? ? System.out.println(id);
? ? ? }
? }
?
? public void method(){
? ? ? class Inner2{ //局部内部类
? ? ? ? ? public void in(){
?
? ? ? ? ? }
? ? ? }
? }
}
//一个java类中有多个class类，但只能有一个public class类
class A {
? public static void main(String[] args) {
?
? }
}
/*
Outer outer = new Outer();
? ? ? outer.out();
? ? ? //通过外部类来实例化内部类
? ? ? Outer.Inner inner = outer.new Inner();
? ? ? inner.in();
? ? ? inner.ID();
*/
package com.oop.demo10;
?
public class Test {
? public static void main(String[] args) {
? ? ? new Apple().eat();//没有名字初始化类，不用把实例保存到变量中
? ? ? new UserService() {//匿名内部类
? ? ? ? ? @Override
? ? ? ? ? public void hello() {
?
? ? ? ? ? }
? ? ? };
? }
}
class Apple{
? public void eat(){
? ? ? System.out.println("1");
? }
}
interface UserService{
? ? void hello();
}
|