java面向对象3

方法的重写

重写：需要有继承关系，子类重写父类的方法！

 1. 方法名必须相同
 2. 参数列表必须相同
 3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
 4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException-->Exception(大)

重写，子类的方法和父类必须要一致；方法体不同！

为什么需要重写：

1. 父类的功能，子类不一定需要，或者不一定满足！

   Alt+Insert : overridde;

父类

 package com.oop.Demo04;
 ?
 public class A {
     //重写都是方法的重写，与属性无关
     public void test(){
         System.out.println("A");
     }
 }

子类

 package com.oop.Demo04;
 ?
 //继承
 public class B extends A{
 ?
     //Override  重写
     @Override//注解：有功能的注释
     public void test() {
         System.out.println("B");
     }
 }

总控制

 package com.oop;
 ?
 import com.oop.Demo04.A;
 import com.oop.Demo04.B;
 ?
 //一个项目应该只有一个Main方法
 public class Application {
 ?
     //静态的方法和非静态的方法区别很大
         //静态方法：方法的调用只和左边定义的数据类型有关
 ?
         //非静态：重写
     public static void main(String[] args) {
         //父类的引用指向了子类
         A a = new B();//子类重写了父类的方法
         a.test();//B
 ?
         B b = new B();
         b.test();//A
     }
 }

多态

多态存在的条件：

 1. 有继承关系
 2. 子类重写父类方法
 3. 父类引用指向子类对象

多态注意事项：

 1. 多态是方法的多态，属性没有多态
 2. 父类和子类，有联系    类型转换异常！  ClassCastException!

不能用多态：

1. static 方法，属于类，它不属于实例

2. final 常量；

3. private方法；

父类

 package com.oop.Demo05;
 ?
 public class Person {
     public void run(){
         System.out.println("run");
     }
 }

子类

 package com.oop.Demo05;
 ?
 public class Student extends Person {
 ?
     @Override
     public void run(){
         System.out.println("son");
     }
 ?
     public void sun(){
         System.out.println("sun");
     }
 }

总控制

package com.oop;

import com.oop.Demo05.Person;
import com.oop.Demo05.Student;

//一个项目应该只有一个Main方法
public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student()
        //new Person()

        //可以指向的引用类型就不确定了：父类的引用指向子类

        //Student调用的方法都是自己的或者继承父类的！
        Student student = new Student();
        //Person 父类型，可以指向子类，但不能调用子类的方法
        Person person = new Student();

        //对象能执行那些方法，主要看对象的左边类型，和右边关系不大！
        student.run();
        person.run();//子类重写了父类的方法，执行子类的方法
        student.sun();

        Person person1 = new Person();
        person1.run();
    }

}

类型转换

1. 父类引用指向子类的对象

2. 把子类转换为父类，向上转型；

3. 把父类转换为子类，向下转型；强制转换

4. 方便方法的调用，减少重复的代码！简介

package com.oop;

import com.oop.Demo05.Person;
import com.oop.Demo05.Student;

//一个项目应该只有一个Main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.run();
        //类型之间的转换：父子

        //高                 低
        Person person = new Student();
        //将person强制转换为Student类型，就可以使用student类型的方法了
        ((Student)person).sun();
    }

}

static关键字

变量和方法：

package com.oop.Demo06;

//静态static
public class Student {
    private static int age;//静态的变量   多线程！
    private double score;//非静态的变量

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);//建议静态的变量使用
        System.out.println(s1.age);
        System.out.println(s1.score);

        Student.run();//可以直接调用该类中的静态方法
        new Student().go();//非静态方法：必须要先new类才能调用
    }

    public static void run(){

    }
    public void go(){

    }
}

代码块：

package com.oop.Demo06;

public class Preson {
    //2.赋初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //1.只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //3.
    public Preson(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Preson preson = new Preson();
        System.out.println("================");
        Preson preson1 = new Preson();
    }
}

静态导入包：

package com.oop.Demo06;

//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

final

被final定义后不能用继承了，相当于断子绝孙

抽象类

abstract来修饰

1. 不能new这个类，只能靠子类 去实现它：约束！

2. 抽象类中可以写普通方法

3. 抽象方法必须在抽象类中

抽象的抽象：约束

4. 存在的意义：抽象出来 提高开发效率

package com.oop.Demo07;

//abstract  抽象类    类extends     单继承~    （接口可以多继承）   
public abstract class Action {
    //约束~有人帮我们实现
    //abstract  抽象方法   只有方法的名字，没有方法的实现
    public abstract void doSomeTging();
}	

package com.oop.Demo07;

//抽象类的所有方法，都必须要继承它子类实现，除非子类也是抽象类，就由子子类实现
public class A extends Action{
    @Override
    public void doSomeTging() {

    }
}

接口

作用：

1. 约束
2. 定义一些方法，让不同的人实现~ 	10---->1
3. public abstract
4. public static final
5. 接口不能被实例化~，接口中没有构造方法~
6. implements可以实现多个接口
7. 必须要重新接口中的方法~

UserService：

package com.oop.Demo08;

//抽象的思维

//interface 定义的关键字  ,接口都需要有实现类
public interface UserService {
    //常量~public static final
     int age = 99;

    //接口中所有定义的方法其实都是抽象的  public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

TimeService：

package com.oop.Demo08;

public interface TimeService {
    void timer();
}

UserServiceImpl：

package com.oop.Demo08;

//抽象类：  extends~
//类 可以实现 接口 implements接口
//实现了接口的类 ， 就需要重写接口中的方法

//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(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. 成员内部类

package com.oop.Demo09;

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是一个外部类");
    }
    public class Inner{
        public void in(){
            System.out.println("这是一个内部类");
        }

        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
    }
}

 public static void main(String[] args) {
     Outer outer = new Outer();
     outer.out();
     //通过这个外部类来实例化内部类
     Outer.Inner inner = outer.new Inner();
     inner.getId();
     inner.in();
 }

2. 静态内部类

给类加上static不能调用不含static的其他类

3. 局部内部类

 //一个java类中只能有一个 public class    但可以有多个class类
 class A{
     public static void main(String[] args) {
         
     }
 }

 //局部内部类
 public void method(){
 ?
     class Inner{
         public void In(){
             
         }
     }
 }

4. 匿名内部类

 package com.oop.Demo09;
 ?
 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();
 }

java面向对象3

原文：https://www.cnblogs.com/qiezi01/p/15129695.html