java面向对象
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
成员变量和局部变量的区别：
-
在类中的位置不同:
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
-
在内存中的位置不同:
成员变量：在堆内存(成员变量属于对象,对象进堆内存)
局部变量：在栈内存(局部变量属于方法,方法进栈内存)
-
生命周期不同:
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
-
初始化值不同:
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
构造方法：
方法名与类名相同(大小也要与类名一致),没有返回值类型，连void都没有
重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
如果我们没有给出构造方法，系统将自动提供一个无参构造方法。如果我们给出了构造方法，系统将不再提供默认的无参构造方法,建议永远自己给出无参构造方法
private关键字的概述和特点:
private关键字是一个权限修饰符,可以修饰成员变量和成员方法, 被其修饰的成员只能在本类中被访问,
当把成员变量用private修饰，需要提供对应的getXxx()和setXxx()方法，private仅仅是封装的一种体现形式,不能说封装就是私有 private int age; //类的成员变量
static 关键字的概述和特点：
static关键字的特点,随着类的加载而加载,优先于对象存在,被类的所有对象共享,可以通过类名调用
什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
static的注意事项:
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法: 静态只能访问静态。
静态变量和成员变量的区别
静态变量属于类，所以也称为为类变量,成员变量属于对象，所以也称为实例变量
静态变量存储于方法区的静态区,成员变量存储于堆内存
静态变量随着类的加载而加载，随着类的消失而消失,成员变量随着对象的创建而存在，随着对象的消失而消失
静态变量可以通过类名调用，也可以通过对象调用,成员变量只能通过对 象名调用
静态的成员方法里面没有ｔｈｉｓ，如果一个类中所有的方法都是静态方法，那么就需要私有化构造函数，让其不能创建类的对象。
代码块
{}括起来的代码被称为代码块,根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块
代码块分类：
局部代码块 :在方法中出现；限定变量生命周期，及早释放，提高内存利用率
构造代码块 (初始化块): 类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块 :类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动,能优先于主方法执行。
public class Student {
public static void main(String[] args){
Person p = new Person();
}
}
class Person {
{
// 构造代码块
System.out.println("Person类构造代码块，创建一个对象就执行一次，优先于构造方法执行");
}
static {
System.out.println("Person类的静态代码块，随类加载，执行一次，优先于构造代码快执行");
}
public Person(){
System.out.println("Person类的构造函数");
}
}
继承（extends）
继承: 提高了代码的复用性,可维护性，让类与类之间产生了关系，是多态的前提，但是类的耦合性增强了，Java只支持单继承，不支持多继承
继承的注意事项：
子类只能继承父类所有非私有的成员(成员方法和成员变量)
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
this和super:
this:代表当前对象的引用,super:代表当前对象父类的引用
this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
super.成员变量 调用父类的成员变量
this(...) 调用本类的构造方法：出现在构造方法的第一条语句上
super(...) 调用父类的构造方法 ：出现在构造方法的第一条语句上
this.成员方法 调用本类的成员方法,也可以调用父类的方法
super.成员方法 调用父类的成员方法
子类中所有的构造方法默认都会访问父类中空参数的构造方法,因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化，每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类
重写父类方法：
重写:子父类出现了一模一样的方法,当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法
方法重写注意事项:
父类中私有方法不能被重写，因为父类私有方法子类根本就无法继承
子类重写父类方法时，访问权限不能更低，最好就一致
父类静态方法，子类也必须通过静态方法进行重写，这个算不上方法重写，叫覆盖
子类重写父类方法的时候，最好声明一模一样
final关键字的概述和特点：
final 修饰类，类不能被继承
final 修饰变量，变量就变成了常量，只能被赋值一次, 一般会与public static 一起使用
final 修饰方法，方法不能被重写
final 修饰变量是：基本类型，是值不能被改变
final 修饰变量是：引用类型，是地址值不能被改变,对象中的属性可以改变
final修饰类的属性变量的初始化时机：一是直接显示初始化，二是在对象构造完毕前即可
多态
多态: 事物存在的多种形态
多态前提:
要有继承关系
要有方法重写
要有父类引用指向子类对象
多态中的成员访问特点: 只有非静态的成员方法,编译看左边,运行看右边
成员变量: 编译看左边(父类)，运行看左边(父类)
成员方法: 编译看左边(父类)，运行看右边(子类)
静态方法: 编译看左边(父类)，运行看左边(父类)
多态中向上转型和向下转型:
Person p = new SuperMan();向上转型 SuperMan sm = (SuperMan)p;向下转型
public class Student {
public static void main(String[] args){
Person p = new Teacher("张三",24);
System.out.println(p.age); // 24
System.out.println(p.name); // 张三
p.study(); // 张三--备课
// 若要想拿到Ｔｅａｃｈｅｒ对象 ,得向下转型
Teacher t = (Teacher)(p);
System.out.println(t.age); // 25
System.out.println(t.name); // 张三--
// 开发的时候一般不会这么写Person p = new Teacher("张三",24);多态主要使用在参数传递时
}
}
class Person {
String name;
int age;
public Person(String name, int age){
this.name = name;
this.age = age;
}
public void study(){
System.out.println(this.name+"学习");
}
}
class Teacher extends Person{
String name;
int age;
public Teacher(String name,int age){
super(name,age);
this.name = name+"--";
this.age = age +1;
}
public void study(){
System.out.println(this.name+"备课");
}
}
多态的优缺点：
提高了代码的维护性（继承保证），提高了代码的扩展性(由多态保证)，缺点是：不能使用子类的特有属性和行为。
instanceof 关键字：
cat instanceof Cat ==> true , 判断前面的对象引用是否是后面的类型。
试题：
class A {
public void show() {
show2();
}
public void show2() {
System.out.println("我");
}
}
class B extends A {
public void show2() {
System.out.println("爱");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("你");
}
}
public class Test2DuoTai {
public static void main(String[] args) {
A a = new B();
a.show(); // 爱
B b = new C();
b.show(); // 你
}
}
抽象类(abstract)
抽象类和抽象方法必须用abstract关键字修饰, 抽象类不能实例化，想实例化可以按照多态的方式，由具体的子类实例化，抽象类的子类 要么是抽象类 要么重写抽象类中的所有抽象方法
abstract class 类名 {}
public abstract void eat();
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
抽象类的成员特点：
成员变量：既可以是变量，也可以是常量，但是成员变量不能用abstract修饰
构造方法：有，用于子类访问父类数据的初始化
成员方法：既可以是抽象的，也可以是非抽象的。抽象方法则强制要求子类重写。
面试题:
一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以,这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
abstract不能和哪些关键字共存
static（可以类名调用但是abstract没有方法体，没有意义） final（不能修改，但abstract强制要重写） private(不能继承，但是abstract强制要重写)
接口
狭义的角度讲就是指java中的interface,广义的角度讲对外提供规则的都是接口 ,接口用关键字interface表示 ，接口里的方法都是抽象方法。
interface 接口名 {}
类实现接口用implements表示
class 类名 implements 接口名 {}
接口不能实例化,只能按照多态的方式来实例化
接口的子类：可以是抽象类。但是意义不大。可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
接口的成员特点：
成员变量；只能是常量，并且是静态的并公共的。默认修饰符：public static final 建议：自己手动给出。可以互换位置
构造方法：接口没有构造方法，不能实列化对象
成员方法：只能是抽象方法。默认修饰符：public abstract建议：自己手动给出
类与类,类与接口,接口与接口的关系：
类与类：继承关系,只能单继承,可以多层继承
类与接口: 实现关系,可以单实现,也可以多实现, 并且还可以在继承一个类的同时实现多个接口
接口与接口: 继承关系,可以单继承,也可以多继承
包
格式：package 包名; 多级包用.分开即可
编译带包的类：javac -d . HelloWorld.java java命令执行带包的类：java 包名.HellWord
不同包下四种权限修饰符的访问：
| 本类 | 同一个包下(子类和无关类) | 不同包下(子类) | 不同包下(无关类) | |
|---|---|---|---|---|
| private | Y | |||
| 默认 | Y | Y | ||
| protected | Y | Y | Y | |
| public | Y | Y | Y | Y |
类及其组成所使用的常见修饰符：
修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
类: 用的最多的就是：public
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
成员变量：用的最多的就是：private
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
构造方法：用的最多的就是：public
- 权限修饰符：private，默认的，protected，public
成员方法：用的最多的就是：public
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
内部类
package com.test;
public class Student {
public static void main(String[] args){
// 获取内部内对象
Outer.inner xx = new Outer().new inner();
xx.method(); // 10
}
}
class Outer{
private int num = 10;
class inner{
public void method(){
System.out.println(num);
}
}
}
内部类访问特点
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象
若内部类被私有，则需要在类中提供一个方法，创建内部类对象。和访问私有的成员变量差不多
若上述代码内部类被静态修饰，要访问则是Outer.inner xx = new Outer.inner();
局部内部类
package com.test;
public class Student {
public static void main(String[] args){
Outer o = new Outer();
o.method();
}
}
class Outer{
private int num = 10;
public void method(){
final int ss = 11;
class inner{
public void print(){
System.out.println(ss);
}
}
inner i = new inner();
i.print();
}
}
局部内部类访问局部变量必须用final修饰,因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
匿名内部类
匿名内部类就是内部类的简化写法。前提：存在一个类或者接口,这个类可以是具体类也可以是抽象类。
匿名内部内中使用同一个方法中的局部变量，那么这个变量得设置为最终变量，即为final修饰
package com.test;
public class Student {
public static void main(String[] args){
Outer o = new Outer();
o.method();
}
}
interface Inter{
public void print();
}
class Outer{
class Inner implements Inter{
public void print(){
System.out.println("print");
}
}
public void method(){
new Inter(){
public void print(){
System.out.println("inter print");
}
}.print();
}
}
匿名内部类在开发中的使用
package com.test;
public class Student {
public static void main(String[] args){
PersonDemo p = new PersonDemo();
p.method(new Person(){ // 匿名内部类当作参数传递，本质把匿名内部类当作一个对象
public void show(){
System.out.println("匿名内部类应用");//匿名内部类应用
}
});
}
}
// 接口和抽象类都行
abstract class Person{
public abstract void show();
}
class PersonDemo{
public void method (Person p){
p.show();
}
}
匿名内部类的试题
package com.test;
public class Student {
public static void main(String[] args){
Inter i = Outer.method();
i.show();
}
}
interface Inter{
void show();
}
class Outer{
// 根据ｍａｉｎ函数的调用来补齐代码
public static Inter method(){
return new Inter(){
public void show(){
System.out.println("内部类对象");
}
};
}
}