Java部分概念理解

第1部分 方法

1.1 方法基本概念

1） 方法：用于封装一段特定功能代码，尽可能一个方法至只实现一个基本功能，相当于C语言中的函数；

2） 方法可以多次调用；

3） 避免代码冗余，便于维护，便于团队合作；

4） 定义方法五要素：修饰词、返回值类型（也可没有void）、方法名、参数（有参数更灵活）、方法体

public static int sum (int a，int b) { }

修饰词 返回值类型 方法名 参数 方法体

5）方法可以嵌套调用

1.2 方法的重写

需要改父类才重写

.1.2.1

1）发生在父子类中，方法名相同，参数表相同，方法体不同

2）重写方法被调用时，看对象类型；子类重写会覆盖父类方法名和参数列表相同的方法，当然用super还是可以调用父类方法

1.2.2、 注意事项：

1） 两大：方法名和参数相同

2）两小：

2.1）子类的返回值类型小于或等于父类的

2.1.1）void和基本类型时，必须相同 ；

2.1.2）引用类型时小于或等于；java认为父类大，子类小

2.2）子类抛出的异常小于或等于父类的

3）一大：子类方法的访问权限要大于或等于父类

1.3 补充：

重写和重载的区别：

1）重写：一个类中，方法名相同，参数列表相同，方法体不同；遵循“运行期”绑定，根据对象调用方法

2）重载：一个类中，方法名相同，参数列表不同，方法体不同；遵循“编译期”绑定，根据引用类型绑定方法

第2部分 类和对象

对象：真实存在的单个个体 如 张三、李四、王五 ， 门口停的宝马；

类：类别/类别，一类个体 如 人，车；

Java类中可以包含所有对象都包含的属性、行为

类是一种数据类型

只能包含:

1)描述对象所共有的特征:------变量

属性-----静的

2)对象所共有的行为:----------方法

行为-----动的

一个类可以创建多个对象

类是对象的模板，对象是类的实例

第3部分 重载

重载就跟付款一样，根据付款方式不同即参数不同，调用不同方法（标签一致的）。

System.out.println(Sting a){};

System.out.println(int b){};

1、在同一个类中，方法名相同， 参数不同

2、编译器在编译时自动根据方法 的签名绑定调用方法

第4部分 构造方法

1、给成员变量赋初值

2、与类同名，没有返回值，也不用写void

3、再创建（new）对象时自动调用

4、若自己不写编译器会有默认无参构造，自己写了不再提供

5、构造可以重载，所以可以自己写有参和无参构造

第5部分 this

this：指代当前对象，哪个调用指的就是哪个对象

方法中访问成员变量之前默认都有个this

this 的用法

1） this.成员变量---------------访问成员变量

2） this.方法名（）------------访问方法，后期基本用不到

3） this（）----------------------调用构造方法，多个构造，构造建相互嵌套调用

补充：

方法里是局部变量

类里方法外是成员变量

引用类型里面装的是地址，根据地址找指向的对象

第6部分  内存管理

6.1堆：

1.1）存储使用new关键字创建的对象（包括成员变量）

1.2) 成员变量生命周期：创建对象存在堆中，对象呗GC回收就结束了

1.3）GC（垃圾回收器）不定时到堆中查看，看到垃圾（没有任何引用所指向的对象）自动回收，回收过程是透明的，并不一定看到垃圾就回收，可以调用System.gc()建议快一点回收

1.4）内存泄漏：不再使用的对象还没有被及时回收（有指向但你不用，可能会导致奔溃），当对象不再使用时应及时将引用设置为null。

6.2 栈：

2.1）用于存储正在调用方法中的所有局部变量（包含参数）

2.2）调用方法时在栈中为该方法分配一块对应的栈帧，栈帧中包含所有的局部变量（包括参数），方法调用结束时，栈帧消失，局部变量一并消失

2.3）局部变量周期：调用方法时存在，方法调用结束时与栈帧一并消失

成员变量：类中，方法外；有默认值

局部变量：方法中，没有默认值

6.3  方法区

3.1） 用于存储.class字节码文件（包括方法）

3.2） 方法只存储一次（多次调用方法用this区分），通过this区分具体是那个引用

第7部分 继承

7.1 继承 和泛化一个意思

程序中继承：代码不用自己写，也能用

1）目的：避免代码重复，有利于代码复用

2）通过extends实现继承

3）父类：放所有子类所共有的属性和行为

子类：放特有的属性和行为

4.）子类继承父类后，子类具有：子类+父类，

5）一个父类可以有多个子类，

一个子类只有一个父类

单一继承

6）继承具有传递性

7）java规定：构造子类之前必须先构造父类方法；子类中如没自己调，则默认调用父类无参构造方法

7.2 super

super（）调用父类方法必须位于子类构造的第一句

super：指向当前对象的父类对象，和this类似

1）super.成员变量名-------------------------------访问父类的成员变量

2）super.方法名（）------------------------------调用父类的方法

3）super（）-----------------------------------------调用父类的构造方法

7.3 向上造型

1） 父类型的引用指向子类型的对象

2） 能点出来什么，看引用的类型

Animal o1 = new animal();

Tiger o2 = new Tiger();

Animal o3 = new Tiger(); //一个老虎对象是动物类型 ，向上造型

Tiger o4 = new Animal(); //错误

class Animal{

}

class Tiger extends Animal{

}

父类可以提供一个公共类型接口，跟接口可以联系起来。

第8部分 package、import、访问控制修饰符、static和final

8.1 package

1）避免类的命名冲突

2）包名有层次结构

建议：域名反写.项目名称.模块名称.类名

cn.tedu.manager.stumanager.Student

3） 建议：包名所有字母都小写

4） 类的完全限定名：包名.类名

8.2  import

1） 作用：声明类/引入类

2） 同包中的类可以直接访问

不同包中的类：用import.包名.类名

import.java.util.Scanner;

Scanner s = new Scanner（System.in）；

int age = s.nextInt();

s.close;

8.3 访问控制修饰符

数据私有化（private），行为公开化（public）

1）public：公开的，任何类

2）private：私有的，本类

3）protected：受保护的，本类、子类、同包类

4）默认的：什么也不写，本类、同包类

类的访问修饰：public和默认的

类成员的访问修饰：如上4种都可以

protected和private可以修饰内部类

java建议所有都加访问权限

8.4 static：静态的

8.4.1 静态变量

1.1）成员变量：

1.1.1）实例变量：1）属于对象的，存在堆中；

2）有几个对象就有几个实例变量；

3）必须通过 对象名.变量名 访问

1.1.2）静态变量：1）用static修饰，属于类的，只有一个，存在方法区中；

2）常常建议通过 类名.变量名 访问；不建议用引用来访问

3）何时使用：所有对象的数据都一样的时候使用，如做班级系统中学生的班级，银行系统中的利率

8.4.2 静态方法

1）用static修饰，属于类的，只有一个，存在方法区中；

2）常常建议通过 类名.变量名 访问；不建议用引用来访问

3） 没有隐式this传递，在静态方法中不能直接访问实例成员，静态方法中只能直接访问静态的

class Aoo{

int a;

static int b;

void show(){ //实例方法

a++;

b++; //Aoo.b++;

}

static void test(){ //静态方法中只能直接访问静态的

a++; //编译错误 ,没有this，在静态方法中不能直接访问实例成员

b++;

}

}

8.4.3 静态块：略

8.5 final

第9部分 抽象

抽象 不完整

1）抽象方法:由abstract修饰，只有方法的定义，没有方法体即不需要“{}”

2）抽象类:由abstract修饰，可以包含抽象方法，也可以包含普通方法

3）包含抽象方法的类，必须是抽象类；类中没有抽象方法，也可以将类声明为抽象类

4）抽象类不能被实例化 Shape s = new Shape();//错误

5）抽象类一般需要被继承:

5.1)子类也声明为抽象类

5.2)子类重写抽象类中所有抽象方法---首选

6）抽象类的意义:

6.1)封装子类公用的成员，为子类提供一个公共的类型

6.2)定义抽象方法，由子类来做不同的实现，但入口(方法名)是一样的

第10部分 接口

//接口声明
[可见度] interface 接口名称 [extends 其他的接口名名] {
        // 声明变量
        // 抽象方法
}

//实例
/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void run();
}

/*接口实现：Implements关键字放在class声明后面。*/

//实例
/* 文件名 : Dog.java */
public class Dog  implements Animal{

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

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

   public int noOfLegs(){
      return 0;
   }

   public static void main(String args[]){
      Dog m = new Dog();
      m.eat();
      m.run();
   }
}

只要遵守了USB规范，就能将设备插入到电脑上

只要遵守了国家盖楼房的标准，这个楼就能卖

只要遵守了这个规范，就能干某件事

1.接口就是一个标准、一个规范

2.接口中只能包含常量和抽象方法

3.接口不能被实例化

接口 引用 = new 实现类(); //向上造型

4.类实现接口，必须将所有抽象方法都实现

5.类可以实现多个接口，用逗号分隔

若类又继承父类又实现接口，需先继承后实现

6.接口与接口之间可以继承