java基础2

面向对象概述并举例说明

· 面向过程强调过程，执行者，强调的是功能行为

· 面向对象强调对象，指挥者，将功能封装进对象，强调具备了功能的对象。

· 面向对象举例

o 煎饼果子

· 面向对象思想的特点

o A：它是一种更符合人们思考习惯的思想

o B：它使复杂的内容简单化

o C：它使我们从执行者变成了指挥者

· 面向对象的特点

o A：封装

o B：继承

o C：多态

· 开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

类和对象的关系

· 使用计算机语言就是不断的在描述现实生活中的事物。

· java中描述事物通过类的形式体现，类是一组相同属性行为的对象的抽象。

· 对象即是该类事物实实在在存在的个体。

· 

举例:

人就是一个类(是把每一个相同属性行为的对象进行抽取)

人的属性:姓名,年龄,身高,体重等

人的行为:吃饭,睡觉,说话,跑,跳等

而我们就是对象(是实实在在存在的个体),具体每个人叫什么名字,年龄多大,身高多高,体重多重等,吃饭怎么吃,睡觉怎么睡,说话怎么说等

描述任意一类事物就是在描述他的属性和行为

分析这句话的属性和行为:

上得了厅堂，下得了厨房，写得了代码，查得出异常，杀得了木马，翻得了围墙（黑客技术），开得起好车，买得起新房，斗得过二奶，打得过流氓。

· 

· 如何创建对象

· (1)类 对现实世界中事物的描述(成员变量和方法)

· (2)对象 现实世界中实际存在具体的个体

· (3)对象的使用以及内存图 new

· 

class Person {

    String name;

    int age;

    public void speak() {

        System.out.println("我的姓名是:" + name + ",我的年龄是:" + age);

    }

}

· 

对象的内存图

· 看图说话

成员变量和局部变量

· (1)作用范围

o 局部变量：方法内public void method(String name) {}

o 成员变量：类中，对整个类有效{成员变量分为两种一种静态的,一种非静态的}

· (2)存储空间

o 局部变量：栈内存

o 成员变量：堆内存{静态的成员变量在方法区,非静态的在对象中在堆内存中}

· (3)初始化值

o 局部变量：在使用前必须手动给值

o 成员变量：jvm默认初始化值。int 0 byte 0 short 0 long 0 double 0.0 boolean false char '\u0000'

· 

class Person {

    int num = 10;

    public void method(){

        int num = 20 ;

        System.out.println(num);

    }

}

· 

匿名对象

· (1)当对对象中的功能只执行一次的时候使用。否则，请你使用有名字的对象。

· 

Person p = new Person();

p.show();

p.show();

new Person().show();

new Person().show();

· 

· (2)用于作为实际参数进行传递。

· 

Person p = new Person();

method(p);

method(new Person());

public static void method(Person p){}

· 

· (3)是否可以用匿名对象调用属性,是否有意义?

封装

· (1)封装的好处：便于重复使用，安全性高。

· (2)private权限修饰符

· 

class Demo{

    private int age;//把属性私有对外提供公共的访问方法,可控性提高了

 

    public void setAge(int age){

        if(age>0 && age<=200){

            this.age = age;

        }else {

            System.out.println("请回火星");

        }

    }

 

    public int getAge(){

        return age;

    }

    /*

    设置是setXxx要传参数

    获取是getXxx要返回值类型,返回值类型和属性一致

    */

}

class DemoTest{

    public static void main(String[] args) {

        Demo d = new Demo();

        d.setAge(-20);

        System.out.println(d.getAge());

    }

}

· 

this关键字及其使用场景

· (1)代表当前对象的引用。使用的时候，谁调用方法，this就代表谁。

· (2)什么时候使用this呢？

o A：当局部变量和成员变量重名的时候,可以用this进行区分。

o B：this调用成员方法

o C：构造函数中使用this

§ this() 必须放在第一行。

· 

同下面的道理：

Person(String name){

    this.name = name;

    System.out.println("有一个参数的构造函数");

}

 

Person(String name,int age){

 

    this("张三");

    this.name = name;

    this.age = age;

    System.out.println("有两个参数的构造函数");

}

Person p = new Person("lisi",20);

Person p2 = new Person("wangwu");

=============================================================================================================================

构造函数

· (1)用途：用于给对象中属性进行初始化。

o 格式:类名(){code}

· 

Person(){

    对对象属性进行初始化代码

}

· 

· 

(2)特点 你不定义空参数的构造函数，系统会自动给一个空参构造，你定义了构造函数无论是有参还空参的，系统就不再给空参数的了。

· 

· (3)重载构造函数,是根据参数列表来区分是哪个构造函数

· 

A：Person(){}

B：Person(int age,String name){}

C：Person(int age){}

D：Person(String name,int age){}

· 

一个对象的创建过程图

· 看图说话

面向对象的练习(定义类-创建对象-使用对象)

class Person {

    private String name;

    private int age;

    public Person() {

        super();

 

    }

    public Person(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

 

}

static关键字

· 静态的意思。可以修饰类的成员(成员变量和成员方法);

静态的内存图及特点

· 看图说话

· A：随着类的加载而加载，生命周期最长。

· B：优先于对象存在。

· C：被所有的对象所共享。

· D：比非静态成员多了一种访问方式。可以通过类名直接调用。建议用类名.调用

什么时候使用static

· 当类中的成员需要被所有对象共享时，用static修饰。不需要被共享时，就不用static修饰。

· 简单说：共性用static修饰，特性不用static修饰。

类变量(静态变量)和实例变量(非静态的成员变量)的区别

· (1)存在内存中的位置：

o (类变量)静态变量随着类的加载而存在于方法区中。

o 实例变量随着对象的建立而存在于堆内存中。

· (2)生命周期:

o 静态变量的生命周期最长，随着类的消失而消失。

o 实例变量的生命周期随着对象的消失而消失。

· (3)所属不同：

o 静态变量也称之为类变量，所属于整个类，被整个类的对象所共享。

o 实例变量是对象的特有数据，所属于对象。

· 举例:定义一个非静态的属性,和一个静态属性,再定义一个静态方法和非静态方法对属性进行输出

帮助文档的制作

· javadoc -d(指定文档存储的位置如果写.代表当前目录,也可以定义一个文件夹)

· @author(提取作者内容)

· @version(提取版本内容)

· javadoc -d 指定的文件目录 -author -version ArrayTool.java

· @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据

· 制作工具说明书:代码中有文档注释,用javadoc解析。

· 

 javadoc -d . myAPI -author -version ArrayTool.java

 -d 后面跟目录,.代表当前目录

 

 javadoc: 错误 - 找不到可以文档化的公共或受保护的类。

 改用public修饰一下即可

· 

如何使用API

· 讲学习过的类查看一下

静态的用场景,工具类

· Math类讲解。

o 随机数。

o 猜数字小游戏。

main方法

· 格式如下：

· 

public static void main(String[] args){//new String[0]

}

· 

· 由于它被jvm调用，所以权限要足够大，所以用public权限修饰符。

· 为了jvm可以不用创建对象直接调用它，所以用static修饰。

· void jvm不需要任何返回。但是方法体结尾默认有return;

· main jvm只认识这个名字。

· String[] 有可能需要传入参数。

· args 字符串数组的名字,只要符合标识符的命名规则可以随便起。

局部代码块&构造代码块&静态代码块

· (1)局部代码块 控制变量的生命周期{int x}

· (2)构造代码块 每创建一次对象就执行一次。

· (3)静态代码块

o 类中加载流程？

o 静态代码块--构造代码块--构造方法。

==========================================================================================================================

1：继承(extends)

· (1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

o 要了解这个体系结构中最共性的内容,就看最顶层的类。

o 要使用这个体系的功能,就用最底层的类创建对象。

· (2)继承的好处：

o A：继承的出现，提高了代码的复用性。

o B：继承的出现，让类与类之间产生了关系，extends来表示，这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。

· (3)特点

o A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。

o B：java支持多重(层)继承。

· (4)注意：

o A：子类可以直接访问父类中的非私有的属性和行为。

o B：不要仅为了获取其他类中部分功能而去继承。

o C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

§ 如何判断A和B是否有继承关系？

§ A如果继承B，那么就可以说A是B的一种。

2：继承后子父类之间成员的关系

· (1)成员变量

· 

class Fu{

    int num = 5;

}

 

class Zi extends Fu{

    int num = 20;

 

 

    public void show() {

        int num = 30;

        System.out.println("num:"+num);

        //当局部变量和成员变量重名的时候用this来区分

        System.out.println("this num:"+this.num);

        //当子类和父类出现了同名变量,用super来区分

        System.out.println("father num:"+super.num);

    }

}

总结:在一个类中如果方法中的局部变量和方法外的成员变量重名,那么如果在方法内输出这变量,就是方法自己的变量里的值,想要区分要用this,加上this.就是输出成员变量的值

在子父类中如果出现成员变量重名的时候,在子类输出会输出自己的变量里的值,想要区分要用super,加上super.就是输出父类里变量的值

 

      this和super的区分：

      **this代表本类对象的引用

    super本类对象父类的引用。

      **this可以用于区分局部变量和成员变量同名的情况。

    super可以用于区分子类和父类成员变量同名的情况。

      **一般，子类中不会出现和父类同名的成员变量。面试可能问到。

· 

· 

(2)成员方法

· 

· 

class Fu {

    public void show() {

        System.out.println("fu show");

    }

    public void method() {}

}

 

class Zi extends Fu{

 

    public void show(){

 

        System.out.println("zi show");

    }

}

子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。

重写(override)和重载(overload)的区别：

重载的特点：

    **在同一类中。

    **方法名相同，参数列表不同。

重写的特点：

    **要有继承关系。在子父类中

    **方法的声明相同。(方法名和参数列表都相同)

        ***覆盖时，子类方法权限一定要大于等于父类方法权限

        父类的权限不能是私有的

        ***静态只能覆盖静态。

· 

· (3)构造方法

· 

class Fu{

 

    Fu(){}

 

    Fu(int age){        

        System.out.println("father age:"+age);

    }

}

 

class Zi extends Fu{

    Zi(){

        this(40);

        System.out.println("son");

    }

 

    Zi(int age){    

        super();

        System.out.println("son age:"+age);

    }

}

 

Zi z = new Zi();  

 

Zi z = new Zi(30);

 

总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。

    **因为每一个构造方法的第一行都有一条默认的语句super();

 

      当父类中没有空参数的构造方法时，子类的构造函数必须通过this

      或者super语句指定要访问的构造方法。或者手动提供无参构造方法。

 

      this(...):调用本类中的构造方法

      super(...):调用父类中的构造方法

 

构造方法用于创建对象，并进行初始化.建议如果你写了有参的构造函数,也要把空参的构造函数再手动加上

否则你定义了有参的构造函数,空参的系统就不会再给了

你这样创建对象的时候就会报错Person p = new Person();//这句话是会去找空参的构造函数

 

 class Person{

        Person(){}

 

    Person(int age){

        this.age = age;

    }

 

    Person(int age,String name){

        this(age);

        //this.age = age;

        this.name = name;

    }

 }

 

      //Person p =new Person();  //系统默认给出无参构造

 

      //当你手动给出构造方法后，系统就不会再给出默认的空的构造方法。

 

 

      手动无参数，如果你想给属性赋值或者做一些初始化，无参你别删不就行了吗。

    class Demo{

        private String name;

        Demo(){}

 

        public void setName(String name){

            this.name = name;

        }

 

        public String getName(){

            return name;

        }

    }

· 

3：final可以用来修饰什么呢？

· (1)final可以用来修饰类：被fainl修饰的类不能被继承。

· (2)final可以用来修饰成员方法：被final修饰的成员方法不能被重写。

· (3)final可以用来修饰变量：被final修饰的变量为常量，值不能被修改。

· 

   常量的命名规范：要求大写。

   final double PI = 3.14;

   final修饰的变量可以在声明的时候直接赋值,还可以在构造方法可以给final修饰的变量赋值。

· 

4：多态

· (1)某一类事物的多种存在形态。

o 方法重载(静态多态)

o 方法重写(动态多态,对象多态)

· (2)对象多态的前提

o A：类与类(或接口)要有继承(或实现)关系。

o B：一定要有方法的重写。

o C：一定要有父类或者接口的引用指向子类的对象。

· 

(3)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西) Fu f = new Zi(); A：成员变量：编译和运行都看Fu。 B：非静态方法：编译看Fu，运行看Zi。 C：静态方法：编译和运行都看Fu。

· 

举例：动物的例子：向上转型 Animal a = new Cat(); a.eat(); //a.catchMouse();

· 

向下转型

Cat c = (Cat)a;

c.eat();

c.catchMouse();

 

//向上转型

Animal a = new Dog();

//向下转型 转换异常

//Cat c = (Cat)a;

Dog d = (Dog)a;

 

总结:无论是向上转型还是向下转型,变化的都是子类对象,绝对不能把父类对象强转为子类类型

· 

· (4)多态的好处和弊端

o 好处:提高了程序的扩展性

弊端:不能使用子类特有的属性和行为 

==========================================================================================================================

1：抽象类(abstract)

· (1)只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。

· (2)抽象类的特点

o A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方法。

o B：抽象类是不能够被实例化的。不能够创建对象的。

o C：如果一个类继承抽象类，那么，它要么重写抽象类中的所有抽象方法，要么本身也是抽象类。

· (3)抽象类的成员特点：

o A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)

o B：成员方法：抽象类中分为两种方法， * 一种是抽象方法，这种方法在子类中必须要被实现。 * 一种是普通的方法。可以被子类直接继承使用。

o C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。它的构造方法有用吗？有，为了让子类实例化的时候使用。

· (4)举例：教师举例，学生举例，员工举例

· (5)抽象类的相关问题：

o A：抽象类中是否有构造函数？参照(3)里面的C。

o B：抽象关键字abstract不可以和哪些关键字共存？

§ private

§ 私有的，外部直接无法访问。子类也同样无法访问

§ abstrac修饰的方法就是为了让子类继承并重写的

§ static

§ 那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。

§ final

§ final修饰的方法不能被重写。所以它和abstract冲突。

o C：抽象类中可不可以没有抽象方法？

§ 可以。如果这么做只有一个目的不让你创建这个类的对象

· (6)模版方法设计模式

· (7)抽象类多态

2：接口(interface)

· (1)接口的由来：当一个类中所有的方法都是抽象的时候，你没必要定义为抽象类，定义为接口就可以了。

· (2)成员特点：

o A：只有成员变量和成员方法。

o B：成员变量 默认修饰符 public static final

§ int X = 20;

§ 其实是这样的 public static final int X = 20;

o C：成员方法 默认修饰符 public abstract

§ void show();

§ 其实是这样的 public abstract void show();

§ 建议：为了便于阅读,自己手动加上修饰符。

· 

(3)解决了java中只能单继承的问题。(对多继承进行了优化)

· 

o A：类与类：只能是单继承。 extends

o B：接口与接口：可以是单继承，也可以是多继承。 extends

o C：类与接口：可以是单实现，也可以是多实现。 implements

· 

(4)接口特点：

· 

o A：接口是对外暴露的规则

o B：接口是功能的扩展

o C：接口降低了程序的耦合性。

§ 内聚(自己实现功能的能力)

§ 高内聚，低耦合。

§ 举例：主板和CPU,USB接口,电源插座。

o D：扩展说了下接口的理解

§ 狭义的理解就是java中的接口。

§ 广义的理解就是：任何定义的规范都是接口。

· (5)接口和抽象类的区别：

o A：抽象类只能被单继承；接口可以被多实现。

o B：

§ 抽象类中的成员：

§ 成员变量:可以是常量，也可以是变量。

§ 成员方法:可以是抽象的，也可以是非抽象的。

§ 构造方法:虽然不可以创建对象，但是可以给子类实例化用。

§ 接口中的成员：

§ 成员变量：只能是常量。默认修饰符 public static final

§ 成员方法：只能是抽象的。默认修饰符 public abstract

o C：抽象类中定义的是体系结构中的共性的内容。接口中定义的是对象的扩展功能。

o D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。接口被实现表示的是: "like a"的关系。xx像yy中的一种。

· 

(6)学生：Student

· 

o A：属性：学号,姓名,年龄

o B：方法：学习(study),吃饭(抽象eat),抽烟(是不是所有的学员都抽烟呢?),篮球(是不是所有的人都会打篮球呢?)

o 分析:学员都具备学习的行为和吃饭的行为,但是并不是所有的学员都抽烟,也不是所有的学员都打篮球

o 

 interface Smoking {

    public abstract void smoking();

 }

 interface Sport{

    public abstract void playBasketBall();

 }

o 

o 

描述的是即会抽烟又会打篮球的学生：SmokeStudent extends Student implements Smoking,Sport

o 

o 一个类只能继承一个类,但是可以实现多个接口,每实现一个接口,功能就扩展了一部分

o 

SmokeStudent ss = new SmokeStudent();

ss.eat();

ss.study();

ss.smoking();

ss.playBasketBall();

o 

· (7)接口多态举例

========================================================================================================================

一.package

· 1.定义包

o 使用package关键字在类的第一条语句定义包名

o 包名必须全部小写, 一般用域名

· 2.编译带包的类

o javac -d <目录> 源文件名.java

o 例如: javac -d . Person.java 编译到当前目录

· 3.默认包

o 如果一个类没有加上package关键字定义包名, 它是在一个默认的包中,以前我们使用的类都没有定义包, 默认都在同一个包中, 互相直接可以直接访问

o 如果两个类定义了包, 并且是相同的包, 也可以直接访问

· 4.运行带包的类

o java 包名.类名(全限定名)

o 例如: java cn.itcast.day11.PackageDemo

· 5.访问权限

o private 私有, 只有当前类可用. 类是不能私有的.

o 默认, 同包中的类可用. 类默认也是只能同包内使用.

o protected 保护, 同包中的类和子类可用. 类不能使用这个修饰符.

o public 公有, 所有的类都可用. 如果一个类希望被其他包中的类使用, 那么必须使用* public修饰. public的类必须和文件名一致.

· 6.导入其他包中的类

o 首先要使用的类必须是public修饰的

o 使用import关键字可以导入其他包中的类

§ a.星号方式导入. 导入指定包中所有的类. 如果当前包中有同名的类, 优先使用当前包中的.

§ b.类名方式导入. 导入指定包中指定的类. 无论当前包中是否有需要的类, 都使用导入的包中的类.

§ 如果一个类中要是用两个包中同名的类, 那么每次使用的时候都加上包名即可

· 7.有包类和无包类之间的访问问题

o 无包的类能访问有包的类吗?

o 有包的类能访问无包的类吗?

· 8.重点

o 写类的时候要加上包名

o 类要public, 并且类名和文件名一致

o 导入类要写类名

o 编译用-d, 运行带包名

二：内部类

· (1)成员内部类

o A：定义,:在一个外部类中有成员变量和成员方法,那么成员内部类就是把整个一个类当成了外部类的成员对待了

o B: 访问方式:内部类访问外部类,内部类可以直接访问外部类,包括私有成员,因为内部类拥有外部类的引用是类名.this

§ 外部类访问内部类,外部类访问外部类的成员,必须要建立内部类的对象

§ 格式:外部类名.内部类名 = 外部类对象.内部类对象;

§ Outer.Inner oi = new Outer().new Inner();//outer代表外部类,Inner代表内部类

o C:存放位置:在外部类里,在外部类的成员方法外.

o D:修饰符:final、abstract、public、private、protected和static等,那么被static修饰的就是下面所说的

· (2)静态内部类

o A：定义,就是在成员内部类的基础上加上static

o B：格式:外部类名.内部类名 = 外部类名.内部类对象; Outer.Inner oi = new Outer.Inner();

o C:存放位置:和成员内部类一样,就是多了个static

· (3)局部内部类

o A：定义,在外部类成员方法中定义的内部类,他更像局部变量

o B: 注意:

§ 第一:方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

§ 第二:方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。

§ 第三:方法内部类的修饰符。与成员内部类不同，方法内部类更像一个局部变量。可以用于修饰方法内部类,的只有final和abstract。

§ 第四:静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。

· (4)匿名内部类：没有名字的内部类。它是内部类的简化写法。是局部内部类的一种

o A：前提：内部类可以继承或实现一个外部类或者接口。

o B：格式为：new 外部类名或者接口名(){覆盖类或者接口中的抽象的方法，(也可以自定义内容。)}

o C：简单理解：就是建立一个带内容的外部类或者接口的子类的匿名对象。

o D: 匿名内部类几种常用方式

§ a,继承式的匿名内部类

§ b,接口式(也可以叫实现式的,名字无所谓)的匿名内部类

§ c,参数式的匿名内部类

§ 多加一句:我的理解,其实与其说是匿名内部类,我个人认为说是匿名对象更确切一点(个人理解,仅供参考);

· 

interface Inter {

    public abstract void show1();

    public abstract void show2();

}

 

//有名字的内部类

class Outer {

    public void method(){

        class Inner implements Inter {

            public void show1(){

                System.out.println("show1");

            }

 

            public void show2(){

                System.out.println("show1");

            }

        }

    }

    public void show() {

        Inter in = new Inner();//父类引用指向子类对象

        in.show1();

        in.show2();

 

    }

}

 

//匿名内部类(重点,android里面用的多,awt的监听器用的多)

class Outer {

    public void method() {

        //匿名内部类对象调用方法

        new Inter() {

            public void show1() {

                System.out.println("show1");

            }

 

            public void show2() {

                System.out.println("show1");

            }

        }.show1();

 

        new Inter() {

            public void show1() {

                System.out.println("show1");

            }

 

            public void show2(){

                System.out.println("show1");

            }

        }.show2();

        //匿名内部类对象的另一种调用方式,父类引用指向子类对象

        Inter in = new Inter() {

            public void show1() {

                System.out.println("show1");

            }

 

            public void show2() {

                System.out.println("show1");

            }

        };

        in.show1();

        in.show2();

    }

}

· 

· 

(5)什么时候使用匿名内部类呢？

· 

o A：通常在使用方法是接口类型参数，并该接口中的方法只有一个时，可以将匿名内部类作为参数传递。