Java 基础

@author 吕重根

01、数据类型

• 基本数据类型

• 引用数据类型（对象和数组）默认值为null

  低 --------------------------------------------------------------> 高
  byte,short,char—> int —> long—> float —> double

1.1、自动类型转换

• 不能对 boolean 类型进行类型转换。

• 不能把对象类型转换为不相关的类的对象。

• 在把容量大的数据类型转换为容量小的数据类型时必须进行强制类型转换。

• 转换的过程中可能导致益处或者损失精度。

1.2、强制类型转换

转换后的数据类型 变量 2= （转换后的数据类型） 变量 1；

1.3、注意事项

• java 中所有变量必须先声明，后赋值才能使用

• java 中成员变量，在创建对象的时候，都会执行一次初始化操作，都会给一个默认值

• 基本数据类型默认值为0 包括boolean -> false

• 引用数据类型：null

• null表示空，什么都没有。 只是占位一下！！！

1.4、java语言变量类型

• 类变量（静态变量）：独立于方法外的变量，用static修饰。

• 成员变量（实例变量）：独立于方法外的变量，不用static修饰。

局部变量：类的方法变量

public class Test{
	static int allClicks=0;  // 类变量
 	String str = "hello world"; // 实例变量
    public void method() {
		int i = 0; // 局部变量
  }
}

02、流程控制

2.1、顺序

2.2、选择

if

2.3、循环

for while do…while

03、数组

3.1、数组的定义

具有相同类型数据的集合。

3.2、java中数组的声明定义

• 类型[ ] 数组名 = new 类型[大小];

• 类型[ ] 数组名= {数据,数据,数据…};

• 类型[ ] 数组名= new 类型[] {数据,数据,数据};

04、方法

4.1、基本结构

修饰符 返回类型 方法名（参数类型 参数名）{

…

方法体

…

return 返回值；

…

}

4.2、静态方法

静态方法也称为类的方法，可以在不创建对象的情况下直接调用，
好处就是调用方便，而且其在内存中只有一份，无论多个线程调用该方法，都只有一个，所以间接上来说省了一部分内存开销，但其实也有不好就是类在加载时就为其分配内存空间而且不会回收，也就是这部分内存一直被占有。

public static void methods(){
    System.out.println("这是一个静态方法");
}

4.3、方法

public void methods(){
    System.out.println("这是一个方法");
}

4.4、非、静态方法区别

1.静态方法可以被类名点调用和对象点调用，非静态的方法只能对象打点调用。

用处允许不创建对象而调用静态方法，是Java为了减少程序员调用某些常用方法时的麻烦，而允许程序员按照传统的C语言中使用函数的方式来使用方法。

2.静态方法只能调用静态的成员，非静态的可以调用静态的成员也可以调用用来实例的成员。

05、重载

5.1、重载定义

方法名相同，参数不同就是重载，形参不同指形参的数量，类型，顺序不同

只有方法名相同以及参数相同顺序相同才是相同的方法。

5.2、重载规则

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

5.3、识别技巧

（看懂下面的代码）：

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

06、封装

6.1、封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

6.2、实现Java封装的步骤

（1）private修饰

public class Person {
    private String name;
    private int age;
}

（2）get set方法

public class Person{
    private String name;
    private int age;
    
    public int getAge(){
      return age;
    }
    
    public String getName(){
      return name;
    }
    
    public void setAge(int age){
      this.age = age;
    }
    
    public void setName(String name){
      this.name = name;
    }
    
}

（3）其他类如果想用本类中的属性，则需要创建对象然后调用get set方法

6.3、this 关键字

• 当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量；

• 在构造函数中，通过this可以调用同一类中别的构造函数；

• 使用this同时传递多个参数。

• 本案例中为了解决实例变量（private String name）和局部变量 setName (String name)中的name变量）之间发生的同名的冲突。

07、继承

7.1、继承定义

​ 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

7.2、继承案例

继承的格式：

class 父类 {
}

//extends 为继承的关键字
class 子类 extends 父类 {
}

企鹅类：

public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

老鼠类：

public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

修改后~~~

公共的父类：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是" + id + "号" + name + "."); 
    } 
}

企鹅类：

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

老鼠类：

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

7.3、super关键字

（待补充）

08、多态

8.1、多态的定义

指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

一个对象的实际类型是确定的，但是可以指向应用类型就不确定了：父类的引用指向子类。

Animal s = new Cat();
//s不能调用子类独有的方法

8.2、注意事项

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

父类和子类有联系，类型转换异常（ClassCastException）

存在条件 继承条件 方法重写 父类引用指向子类对象！

static final private修饰无法重写

8.3、向上转型

通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换

class A {
         public void print() {
                  System.out.println("A:print");
         }
}

class B extends A {
         public void print() {        
                  System.out.println("B:print");
         }
}

public class Test{
         public static void main(String args[])
         {
                  A a = new B();          //通过子类去实例化父类
                  a.print();
         }
}

class A {
         public void print() {
                  System.out.println("A:print");
         }
}

class B extends A {
         public void print() {        
                  System.out.println("B:print");
         }
}

class C extends B {
         public void print() {        
                  System.out.println("C:print");
         }
}

public class Test{
         public static void func(A a)
         {
                  a.print();
         }

         public static void main(String args[])
         {
                  func(new B());  //等价于 A a =new B();
                  func(new C());  //等价于 A a =new C();
         }
}

8.4、向下转型

通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换

class A {
         public void print() {
                  System.out.println("A:print");
         }
}

class B extends A {
         public void print() {        
                  System.out.println("B:print");
         }
         public void funcB(){
                  System.out.println("funcB");
         }
}

class C extends A {
         public void print() {        
                  System.out.println("C:print");
         }
         public void funcC(){
                  System.out.println("funcC");
         }
}

public class Test{
         public static void func(A a)
         {
                  a.print();
                  if(a instanceof B)
                  {
                          B b = (B)a;   //向下转型,通过父类实例化子类
                          b.funcB();    //调用B类独有的方法
                  }
                  else if(a instanceof C)
                  {
                          C c = (C)a;  //向下转型,通过父类实例化子类
                          c.funcC();   //调用C类独有的方法
                  }
         }

         public static void main(String args[])
         {
                  func(new A());   
                  func(new B());
                  func(new C());
         }
}

8.5、多态的好处

1. 可替换性（substitutability）

   ​ 多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

2. 可扩充性（extensibility）

   ​ 多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

3. 接口性（interface-ability）

   ​ 多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

4. 灵活性（flexibility）

   ​ 它在应用中体现了灵活多样的操作，提高了使用效率。

5. 简化性（simplicity）

   ​ 多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

8.6、instanceof

通过instanceof可以判断某对象是否是某类的实例,如果是则返回true,否则为false.

instanceof使用如下:

A a = new B();                 //向上转型 (B类是A的子类)
a instanceof A;                //返回true.
a instanceof B;                //返回true
a instanceof C;