寒假java学习基础篇61~79

1.面向对象

概念：将问题拆为小块进行解决，适合协作

三大特征

封装，继承（子继承父），多态（同种事物不同形态）

方法调用

static和类同步加载，所以非静态可调用静态，否则调用规则按顺序

静态方法可直接调用，非静态则需要实例化new

public class d1 {
    public static void main(String[] args) {
        d2.say();//可直接调用
    }
}


public class d2 {//静态方法无static
    public static void say(){
        System.out.print("学生说话了");
    }
}

public class d1 {
    public static void main(String[] args) {
    //new实例化    
    //对象类型   对象名=对象值
        d2 student = new d2();
        student.say();
    }
}


public class d2 {//非静态方法
    public void say(){
        System.out.print("学生说话了");
    }
}

类似于c的地址关系

public class d1 {
    public static void main(String[] args) {//值传递
        int a = 1;
        System.out.println(a);//1
        d1.change(a);
        System.out.println(a);//1

    }
    //返回值为空
        public static void change(int a){
            a=10;//a传入值，void不返回
        }
    }

我的理解：当new实例化之后便生成一个指向，类似于地址

public class d1 {
//址传递
    public static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name);//null
        d1.change(perosn);
        System.out.println(perosn.name);//秦疆
    }
    public static void change(Perosn perosn) {
//perosn是一个对象：指向的---＞ Perosn perosn ＝ new Perosn（）；
//这是一个具体的人，可以改变属性！
        perosn.name = "秦疆";
    }
}
//定义了一个单独的Perosn类，有一个属性：name
class Perosn{
            String name;
    }

类与对象

类属于一个范围，对象指到实例

以类方式组织代码，以对象方式组织数据

public class damo02 {//类似
    String name;//默认是null
    int age;
     public void study(){
         System.out.println(this.name+"在学习");
     }
}

public class damo01 {
    public static void main(String[] args) {
        //类：抽象的，需实例化
        //类实例化后返回一个自己的对象
        //demo02对象就是一个damo02类的具体实例
        damo02 xiaoming=new damo02();
        xiaoming.name="xiaoming";
        xiaoming.age=3;
    System.out.println(xiaoming.name);
    System.out.println(xiaoming.age);
    xiaoming.study();//输出xiaoming在学习
    }
}

构造器

1.一个类什么都不写，也会自动存在一个方法 public a(){}

2.使用new时必须要构造器，本质是在调用构造器，可以来初始化（无参函数不写内容）

public class d1 {
    //一个类什么也不写也会存在一个方法
    //显示的定义构造器
    String name;
    //使用new关键字本质是在调用构造器
    //用来初始化值
    public d1(){
    }
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public d1(String name){
        this.name=name;
    }
}


    public static void main(String[] args) {
        //new实例化一个对象
        d1 d1 = new d1("fazhu");
        System.out.println(d1.name);
    }
}

创建对象内存分析p65

顺序

1.加载类中main，常量池，方法区中存放方法

2.栈中生成对象，指向有方法为模板生成的类

public class d1 {
    public static void main(String[] args) {
        d2 dog = new d2();
        dog.name="旺财";
        dog.age=3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}


public String name;
public  int age;
//无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

类与对象小结

动态的行为，方法

2.封装

高内聚，低耦合 ：内部数据自己操作，不允许外部干涉；仅暴露少量给外部使用

属性私有，get/set

private----私有的,与public对应

alt+insert（笔记本加Fn）快速生成get/set方法

意义

1.提高程序安全性，保护数据

2.隐藏代码实现细节

3.统一接口

4.系统可维护性增加

public class demo1 {
    public static void main(String[] args) {
        demo2 s1=new demo2();
        s1.setName("法助");
        System.out.println(s1.getName());
        s1.setAge(72);
        System.out.print(s1.getAge());
    }
}

public class demo2 {
   private String name;
   private int id;
   private char sex;
   private int age;
   //属性私有，属性不可操作
   public String getName(){//利用get方法获取
       return this.name;
   }
   public void setName(String name){//利用set方法赋值
       this.name=name;
   }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0){//判断合理性
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}//alt+insert

3.继承

extends---继承（public class Student extends Person)学生为子类

继承后可以使用其中的类方法（私有的类不行），只能单继承（子类只能有一个父类）

java中所有的类，都默认直接或间接继承object

public,protected,default,private

Alt+h:快捷打开树

1.调用有参时在子类记得调用有参，默认调用无参

2.super调用父类构造方法，必须在构造方法的第一位

super必须只能出现在子类方法或构造方法中

super和this不能同时调用构造方法

3.（代表对象）this 本身调用者这个对象；super：代表父类对象的应用；

4（前提）.this：没有继承也可以使用/super：只能在继承条件下使用

5.（构造方法）this（）：本类的构造/super（）父类的构造

//父 类
public class demo3 {

    public demo3() {
        System.out.println("父类无参执行");
    }

    protected  String name="fazhu";
    public void print(){
        System.out.println(("person"));
    }
}

//子类
public class demo2 extends demo3 {
    public demo2() {
        //隐藏代码，调用了父类的无参构造super()
        super();
        //调用构造器，必须要在第一行，会默认调用父类
        System.out.println("子类无参构造了");
    }

    private String name ="qing";
    public void print(){
        System.out.println("student");
    }
    public void test1(){
       print();//student
       this.print();//student
       super.print();//person
    }
   public void test(String name){
        System.out.println(name);//fa
        System.out.println(this.name);//qing
        System.out.println(super.name);//fazhu
    }
}
//测试类
public class demo1 {
    public static void main(String[] args) {
        demo2 student= new demo2();
        //student.test("fa");
        //student.test1();

    }
}

4.重写

ail+ins有重写 非静态的方法：重写。

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

1.方法名必须相同。2.参数列表相同（不然成重载）

3.修饰符：范围可以扩大但不能缩小； public,protected,default,private

4.抛出的异常可以缩小不能扩大；

重写原因：

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

静态跟非静态调用时区别很大

public class d1 {//d2是d3子类，d1调用
    public static void main(String[] args) {
        d2 d2=new d2();
        d2.test();
        d3 d3=new d3();
        d3.test();
    }
}

public class d2 extends d3{//d2继承d3
    public static void test(){
        System.out.println("A=>test");
    }
}

public class d1 {//d2是d3子类，d1调用
    public static void main(String[] args) {
        d2 d2=new d2();//输出A
        d2.test();

        //父类的引用指向了子类
        d3 d3=new d2();
        d3.test();//输出b
    }
}

有static时，调用的时类的方法，即b调用的B的方法

没有static时，调用的是对象的方法，即b是A类new出来的

public class d1 {//d2是d3子类，d1调用
    public static void main(String[] args) {
        d2 d2=new d2();
        d2.test();

        //父类的引用指向了子类
        d3 d3=new d2();
        d3.test();
    }
}

public class d2 extends d3{//d2继承d3
    public void test(){
        System.out.println("A=>test");
    }
}

public class d3 {
    //重写是方法的重写，和属性无关
    public  void test() {
        System.out.println("b=>test");
    }
}

5.多态

1.多态是方法的多态，属性没有多态

public class person {
    public void run(){
        System.out.println("run");
    }
}

public class student extends person {
    public void run(){
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

public class application {
    public static void main(String[] args) {
        //一个对象的实际类型是确认的
        //new student();
        //new person();
         //可以指向的引用类型就不确定了
        //student 能调用自己或者继承父类的
        student s1=new student();
        //person父类型可以指向子类但不能调用子类独有的类型
        person s2=new student();
        Object s3=new student();

        //对象指向哪些方法，主要看对象左边的类型，与右无关
        s1.run();
        s2.run();//类型转换
    }
}

6.instanceof

A instanceof b----------判断a是否是b的父类，看类型是否一样，输出布尔值。不同会报错，如

子类转父类可能丢失自己本来的一些方法

7.static静态方法

static与对象同时产生，即最先

final修饰符后不能被继承

public class person {
    {//赋初始值用
        System.out.println("匿名代码块");//匿名代码块
    }

    public person(){
        System.out.println("构造方法");
    }
    static{//只执行一次
        System.out.println("静态代码块");//静态代码块
    }
    public static void main(String[] args) {
      person person=new person();
      //输出顺序：静态，匿名，构造
        System.out.println("============================");
        person person2=new person();
        //输出匿名，构造
    }
}

随机数

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

public class test {
    public static void main(String[] args) {
//        System.out.println(Math.random());
        System.out.println(random());//随机数
    }
}

8.抽象类

//abstract 抽象类：类 extends: 单继承 （接口可以多继承）
public abstract class action {
    //约束~有人帮实现
    //abstract,抽象方法,只有方法名字，没有方法的实现
    public abstract void doSomething();
    /*1.不能new出来抽象类，只能靠子类去实现；约束！
    2.抽象类里可以写普通方法。抽象方法必须在抽象类里
    意义：提高开发效率（如创造角色，抽象公有属性）
     */
}

//抽象类的所有方法，继承了它的子类，都必须实现他的方法
public class a extends action{

    public void doSomething() {

    }
}

9.接口

声明类的关键字是class，声明接口的关键字是interface

作用：1.约束。2.定义一些方法，让不同的人实现~

3.方法都是public abstract 4.常量public static final

5.接口不能被实例化~接口中没有构造方法

6.implements可以实现多个接口

7.必须要重写接口中的方法

//抽象类：extends
//类 可以实现接口 implements 接口
//实现接口的类，就需要重写接口的方法
//利用接口实现多继承
//类里有方法的实现，接口只有方法定义
//用快捷键生成方法
public class UserSevicelmpl implements UserSevice,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() {
    }
}


public interface TimeService {
    void timer();
}


public interface UserSevice {
    //静态常量 public static final(不常用)
    int age=99;
    //接口中的所有定义的方法都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

10.内部类

内部类：一个类里面定义的类叫作内部类

内部类可直接访问外部类属性

public class outer {

    private int id;
    public void out(){
        System.out.println("这是外部类");
    }
    public class Inner{//此为内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

 //局部内部类
    public void in(){
        class Inner{
            public void in(){

            }
        }
    }
}
/*一个java类中可以有多个class类，但是只能有一个public class
*/


public class a {
    public static void main(String[] args) {
        //new 方法
       outer outer = new outer();
       //通过外部类来实例化内部类
       内部类.outer.Inner inner = outer.new Inner();
       inner.getID();
    }
}

public class a1 {
    public static void main(String[] args) {
        new a().eat();
       UserService userService= new UserService(){
            @Override
            public void hello() {
            }
        };
    }
}
class a{
    public void eat(){
        System.out.println("a");
    }
}
interface UserService{
    void hello();

}


public class a2 {
}

 

11.异常

概念

Exception---异常

Error-----错误

处理异常

try{监控区域}catch（异常类型）{类型相同执行}finally{无论是否异常都执行}

ctrl+alt+t：选择包围

错误使用可以避免运行停止

public class a {
    public static void main(String[] args) {
        /*int a= 0;
        int b= 0;
       try{//try监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){//想要捕获的异常类型，e为标识符
            System.out.println("异常");
            e.printStackTrace();//打印错误的栈信息
        }catch (Exception r){//层层递进，下面范围大
            System.out.println("异常");
        }catch (Throwable t){//多个异常，自上而下捕获，从小到大
            System.out.println("异常");
        }
        finally {//处理善后，一般用于 关闭资源
            System.out.println("验证完毕");
        }
    */
        try {
            new a().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }

    //假设方法中，处理不了这个异常，方法上抛出异常throws
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){//throw不同与throws
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
        System.out.println(a/b);
    }
}

自定义异常

//自定义的异常类
public class text {
    //存在异常的方法
    static void text(int a) throws MyException {
        if (a > 10) {
            throw new MyException(a);//抛出异常
        }
        System.out.println("ok");
    }


    public static void main(String[] args) {
        try {
            text(11);
        } catch (Exception e) {
        //增加处理异常的代码
            System.out.println("MyException=>" + e);
        }
    }
}


public class MyException extends Exception{//继承E内置代码
    private int detail;
    public MyException(int a){
        this.detail=a;
    }
    //toString异常打印信息   alt+ins

    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}