Java 学习之过错（二）

1.外部类与内部类

1） 外部类是不能直接使用内部类的成员和方法滴

2） 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字 外部类类名.this.

例：this.HelloWorld.name    

3）如果内部类和外部类不具有相同的成员变量或方法，可以直接声明使用。

2.包

一.包的作用：管理Java文件，解决同名文件冲突
  二.定义包：package 包名
//必须放在Java源程序的第一行
包名间可以使用“.”隔开
三.系统中的包：
java.(功能).(类)
java.lang.(类) 包含Java语言基础的类
java.util.(类) 包含Java语言中各种工具类
java.io.(类)  包含输入，输出相关功能的类
四.包的使用：
1.可以通过使用import关键字，在某个文件使用其他文件中的类
2.Java中，包的命名规范是全小写字母拼写
3.使用的时候不但可以加载某个包下的所有文件 eg：com.imooc.*
也可以加载某个具体子包下的所有文件

3.成员内部类

//外部类HelloWorldpublic class HelloWorld{        //外部类的私有属性name    private String name = "imooc";        //外部类的成员属性    int age = 20;    //成员内部类Innerpublic class Inner {String name = "爱慕课";        //内部类中的方法public void show() { System.out.println("外部类中的name：" +  HelloWorld.this.name); //在内部类中使用与内部类重复的外部类变量System.out.println("内部类中的name：" +  name);System.out.println("外部类中的age：" + age);}}    //测试成员内部类public static void main(String[] args) {                //创建外部类的对象HelloWorld o = new HelloWorld ();                 //注意创建内部类的对象  是利用外部类的对象进行声明Inner inn = o.new Inner();                    //调用内部类对象的show方法inn.show();}}

4.静态内部类：相比于成员内部类，此类可以直接定义

如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

//外部类public class HelloWorld {        // 外部类中的静态变量score    private static int score = 84;        // 创建静态内部类public static class SInner {        // 内部类中的变量score        int score = 91;        public void show() {System.out.println("访问外部类中的score：" + HelloWorld.score);System.out.println("访问内部类中的score：" + score);}}// 测试静态内部类public static void main(String[] args) {// 直接创建内部类的对象        SInner si = new SInner();                // 调用show方法si.show();}}

5.继承：

方法的重写，构造的先后顺序为先父类后子类

final一经使用，对于变量则不可改变，对于方法和类不可以继承

package com;//包名 compublic class inital {public static void main(String[] args) {// TODO Auto-generated method stub  Animal animal = new Animal();  System.out.println(animal.age);      Dog dog = new Dog();//构造的时候先父类再子类      //dog.age=10;//继承      dog.name="xiaotian";      //dog.eat();//重写      //dog.method();}}

package com;public class Animal {  //finalpublic int age=20;public String name;/*public Animal()//final public Animal() 定义成final后不可被子类继承{System.out.println("Animal执行了");age=10;}*//*public Animal(int a)         //有参的构造函数{System.out.println("Animal执行了");age=10;}*/public void eat() {               //final int a=20;//a=10;System.out.println(name+"动物具有吃东西的能力");}}

package com;public class Dog extends Animal {public int age=200;public Dog(){//super(); super相当于显示的调用父类的构造方法，系统一般默认的调用已经存在的构造方法System.out.println("Dog执行了");}public void eat() {     //方法的重写System.out.println(name+"狗具有吃东西的能力");}public void method(){//System.out.println(age);System.out.println(super.age);}}

6.重写方法（调用Source）

toString方法如果没有重写，直接输出的是它的地址

重写后输出的是它的属性值

equal方法如果没有重写，比较的是2个变量的地址

重写后比较的是它的属性值

7.类型转换

强制转换与instanceof（判断2个是否属于同一类型）

package project3;public class Animal {   public void eat()   {   System.out.println("111Animal");   }}

package project3;public class Cat extends Animal {}

package project3;public class Dog extends Animal { public void eat()   {   System.out.println("222Dog");   }}

package project3;public class Initial {public static void main(String[] args) {// TODO Auto-generated method stub      /*  Animal a1 = new Animal();        Animal a2 = new Dog();  //父类的引用是可以指向子类的        Animal a3 = new Cat();        a1.eat();        a2.eat();        a3.eat();        //错误  Dog    a3 = new Animal();         */        Dog dog = new Dog();        Animal animal = new Dog();//把父类看成基层，所以为向上类型转换              // Cat cat = (Cat) animal; //1 编译时 Cat类型  2运行时 Dog类型       if(animal instanceof Dog) {     Dog dog2 = (Dog)animal; //强制向下类型转换        }       else {       System.out.println("无法进行类型转换Dog");        }        if(animal instanceof Cat) {     Cat cat = (Cat)animal; //强制向下类型转换        }       else {       System.out.println("无法进行类型转换Cat");            }       }}

8.抽象 ：父类用来约束子类必须有那些类，只进行约束，不关心子类怎么实现

abstract定义抽象类

abstract定义抽象方法，只用声明，不用实现（实现了也无实际输出结果的影响）

包含抽象方法的类一定是抽象类

抽象类中可以有普通的方法，也可以不包换抽象方法

package project4;public abstract class Telephone {public abstract void message();}

package project4;public class Smartphone extends Telephone {@Overridepublic void message() {// TODO Auto-generated method stub        System.out.println("Smartphone message");}}

package project4;public class phone extends Telephone {   public  void message() {   System.out.println("Telephone message");   }}

package project4;public class Initial {public static void main(String[] args) {// TODO Auto-generated method stub        phone p1 = new phone();        Smartphone p2 = new Smartphone();        p1.message();        p2.message();}}

9.接口

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类,他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

[修饰符]   class   类名 extends 父类   implentments 接口1 接口2

当一个类继承了抽象类，则需要实现继承的抽象方法，如果是接口，则实现接口中的方法

package project4;public abstract class Telephone {public abstract void message();}

package project4;public interface Iplayganme {   public void play(); }

package project4;public class Smartphone extends Telephone implements Iplayganme{@Overridepublic void message() {// TODO Auto-generated method stub        System.out.println("Smartphone message");}public void play(){System.out.println("Smartphone play");}}

package project4;public class Psp implements Iplayganme {@Overridepublic void play() {// TODO Auto-generated method stub      System.out.println("Psp玩游戏");}}

package project4;public class Initial {public static void main(String[] args) {// TODO Auto-generated method stub       /* phone p1 = new phone();        Smartphone p2 = new Smartphone();        p1.message();        p2.message();*/        Iplayganme ip1 = new Psp();        Iplayganme ip2 = new Smartphone();        ip1.play();        ip2.play();        Iplayganme ip3 = new Iplayganme() {@Overridepublic void play() {// TODO Auto-generated method stubSystem.out.println("使用匿名内部类1");}                };        ip3.play();        new Iplayganme() {        public void play() {// TODO Auto-generated method stubSystem.out.println("使用匿名内部类2");}                }.play();        }}