JAVA笔记

1.静态属性static

---

意义：该数据需共同使用，如同一个学校，同一个班

可以通过类名Person.sid直接访问

公共静态属性：
public static String name="hsy"

私有静态属性：
private static String school="重庆大学"

静态方法：只能调用静态属性
public static void add(){...}

2.final修饰 

---

final不可改变的值、不能重写的方法，不能被继承

final int k=100;

public final void add(){...}

3.抽象类abstract

---

抽象方法必须重写，用abstract修饰

意义在于继承

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
             void eat(){
                   System.out.println("一顿不吃饿得慌");
        }
}

4.接口

---

类似抽象类

内部方法必须重写

意义在于多态

interface add {
    void draw();
}

 5.异常

import java.util.Scanner;


public class Demo4 {

    public static boolean isNull(String input) throws RegisterException{

        if (input.isEmpty()){

            throw new RegisterException("输入信息不能为空");

        }

        return true;



    }

    public static void main(String[] args) {

        boolean temp;

        Scanner scanner=new Scanner(System.in);

        String inputString=scanner.nextLine();

        try {

            temp=isNull(inputString);

            System.out.println(temp);

        } catch (RegisterException e) {

            e.printStackTrace();

        }finally {

            System.out.println("异常处理实例");

        }

    }

}

class RegisterException extends Exception{

    public RegisterException() {

    }

    public RegisterException(String msg) {

        super(msg);

    }

}

 对象转型

向上转型：自动转型

Person hsy=new Student();

 Pig pig = new Pig();
 Animal animal = pig;//转型：自动向上转型

向下转型：强制类型转换

Pig pig = new Pig();
Animal animal = pig;   //转型：自动向上转型
      //将Animal转为Pig类型
Pig pig = (Pig)animal ;//转型：强制向下转型

泛型 

在main中实现型 

类：

class Gen<T,V>
{ 
   private T data;
   private V name;
}
public class hello
   public static main(String arg[])
{ 
  {
     Gen<int,String> aaa=new Gen<int,String>(); //实例化泛型

  }
}

接口： 

interface Gen<T>
{
   private T name;
   T getT(T name,int num);
}
class Sub<T> implements Gen<T>
{
   private T class;
   T getT(){
         return T;
     }
}

在子类中实现泛型：

interface Gen<T>
{
   private T name;
   T getT();
}
class Sub implements Gen<String>  //注意！！！此时已经规定泛型类型
{
   private T class;
   T getT() {
         return T;
        }
}

实现泛型方法：静态

pubic class Utils{
    public static <T> void display(Gen<T> aa) //注意格式！！！
{
      System.out.println("姓名"+ aa.getname +"年龄"+ aa.getage );
}

测试类总览：类名.方法

public class Test{
   public static void main(String[] args){
     Society<String> aaa=new Society<>();  //实例化为空值，此时这里没有构造方法，注意格式！
     aaa.set("啦啦啦",39);     //调用方法初始化
     Utils.display(aaa);      //类名.方法 调用泛型方法！！！！
  }
}