黑马程序员-java-类，java内部类-java构造方法-案例

 内部类
内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹名相同
内部类可以是static静态的，也可以用public default protected private 修饰
而外部类会使用public defaullt
内部类是一个编译概念，一旦编译成功，就会成为不同的类outer.class outer$inner.class
所以内部类的成员变量方法名可以与外部类的相同，分为成员内部类，局部类，嵌套内部类，匿名内部类

1.异常的处理和产生
 try-catch-finall,其中finally可有可无是作为统一的出口
 throw关键字在程序中人为的抛出异常
 throws 关键字是在方法声明处使用，表示此方法不处理任何异常
 static import 是在jdk1.5之后新增的功能属于静态导入
 异常中可以使用assert关键字判断程序到某个位置确定是某个内容但是一般情况下不使用
 一些系统包 java.lang
2. 宠物商店
 宠         猫
 物   标准  狗
 商
 点        老虎
 1-----------*
  在实例开发中，使用接口表示一种标准，表示一种能力（标识接口）标识将主方法名称（方法视图）暴露给远程客户端
 package org.demo.java;
import java.util.*;
interface Pet{
    public String getName();
    public int getAge();
    public float getPrice();
}
//宠物商店 
class PetShop{
    private Pet pets[];
    private int foot;
    public PetShop(int len){
        if(len>0){
            this.pets=new Pet[len];
        }
        else{
            this.pets=new Pet[1];
        }
    }
    public boolean add(Pet per){
        if(this.foot<this.pets.length){
            this.pets[this.foot]=per;
            this.foot++;
            return true;
        }
        else{
            return false;
        }
    }
    //因为查询的时候可能返回多个内用
    public Pet[] serch(String keyword){
        Pet[] result =null;
        int count =0;
        for(int i=0 ;i<this.pets.length ;i++ ){
            if(this.pets[i]!=null){
                if(this.pets[i].getName().indexOf(keyword)!=-1){
                    count++;
                }
            }
        }
        result =new Pet[count];
        count=0;
        for(Pet p :pets){
            if(p!=null){
                if(p.getName().indexOf(keyword) !=-1){
                    result[count]=p;
                    count++;
                }
            }
        }
        return result;
    }
}
class Cat implements Pet{
    private String name;
    private int age;
    private float price;
    public Cat(String name, int age, float price) {
        super();
        this.name = name;
        this.age = age;
        this.price = price;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
    public float getPrice() {
        return this.age;
    }
    public String toString() {
        return "宠物猫的名字"+this.name+"宠物猫的年龄"+this.age+"宠物猫的价格"+this.price+" ";
    }
}
class Dog implements Pet{
    private String name;
    private int age;
    private float price;
    public Dog(String name, int age, float price) {
        super();
        this.name = name;
        this.age = age;
        this.price = price;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
    public float getPrice() {
        return this.price;
    }
    public String toString() {
        return "宠物狗的名字:"+this.name+" 宠物狗的年龄:"+this.age+ "宠物狗的价格:"+this.price+"￥ ";
    }
}
public class text {
    public static void main(String[]args){
        PetShop shop =new PetShop(5);//定义就存放5个宠物的商店
        shop.add(new Cat("黑猫",3,86.4f));
        shop.add(new Cat("白猫", 2,19.5f));
        shop.add(new Cat("花猫",5, 54.8f));
        shop.add(new Dog("白狗",2 ,65.85f ));
        shop.add(new Dog("黑狗", 3, 65.2f));
        Pet p[]=shop.serch("狗");
        for(int x=0 ;x<p.length ;x++ ){
            System.out.println(p[x]);
        }
    }
}
宠物狗的名字:白狗 宠物狗的年龄:2宠物狗的价格:65.85￥ 
宠物狗的名字:黑狗 宠物狗的年龄:3宠物狗的价格:65.2￥ 
 实际上从开发模式也经常使用到，所以理解代码信息，镜像解耦合操作
 接口完成使得开发更加灵活
<3.构造方法
    构造方法：在每个类中都存在一个构造方法，构造方法的目的是为类中的属性初始化的
构造方法定义的时候
  1.构造方法的名最必须和类的名字一样
  2.构造方法在定义是没返回值类型
  3.不能在构造方法中使用return返回一个内容
  4.如果在一个类中没有明确的声明一个构造方法的话，则会自动生成一个无参的省么都不做的构造方法
在类创建时在类对象声明时是不加载构造方法的！
public class text {
    public static void main(String[]args){
        person p=null;
        //p=new person();
    }
}
在实例化对象时即使用关键字new时创建构造方法
构造方法可以重载
但是当一个类中声明了一个明确的构造方法就不会提供无参的构造方法
package org.demo.java;
import java.util.*;
class person{
    String name;
    int age;
    public person(){}
    public person(String name, int age) {
        super();
        this.setName(name);
        this.setAge(age);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {     //这里已经伴随了对象的封装
        if(age>0){
            this.age = age;
        }
        else{
            System.out.println("出现错误。。");
            this.age=0;
        }
    }
    public String toString() {
        return "姓名:"+this.getName()+"年龄"+this.getAge();
    }
}
public class text {
    public static void main(String[]args){
        person p=null;
        p=new person("王琪",-30);
        System.out.println(p);
    }
}
一定要注意的是：构造方法一定要在使用关键字new的时候才被调用，而且一个类中只允许存在至少一个构造方法
<4.构造方法的私有化
        使用private 关键字可以声明属性，声明的属性不能被外部直接访问，同样，可以使用private声明方法
只能在类的内部看见。
        构造方法实际上也可以使用private关键字声明，一旦声明后，则外部无法访问实例化操作
class Single{
    static Single s= new Single();
    private Single(){
        System.out.println("**");
    }
    public static Single getSingle(){
        System.out.println("##");
        return s;
    }
    public void print(){
        System.out.println("Hello word..");
    }
}
public class SingleDemo {
    public static void main(String[]args){
        Single d=null;
         d=Single.getSingle();
        d.print();
    }
}                                  
此程序的意义在于，如果现在一个类只能有一个实例化对象
那么这样的设计就叫做单例设计

<4观察者设计模式
如果要想实现这样的管缠着设计模式，需要佘勇Observer接口和Observablele类
import java.util.Observable;
import java.util.Observer;
class Person implements Observer{
    @Override
    public void update(Observable arg0, Object arg1) {//arg1表示改变后的内容 arg0表示观察的对象
        // TODO Auto-generated method stub
        System.out.println("被观察的感测的 "+arg0+" 有改变 "+arg1);
    }
}
class House extends Observable {
    private float price;
    public House(float price){
        this.price=price;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.setChanged();
        this.price = price;
        super.notifyObservers(price);
    }
    public String toString(){
        return "房子";
    }
}
public class Text{
    public static void main(String[]args){
        House h=new House(3000.0f);
        Person p1=new Person();
        Person p2=new Person();
        Person p3=new Person();
        h.addObserver(p1);
        h.addObserver(p2);
        h.addObserver(p3);
        h.setPrice(6000.0f);
    }
}
    当房子的价格被改变的时候首先要设置改变的发生点，
    之后通过notifyObservers()唤醒全部的观察着
    在主方法设置观察者的对象。

<5.程序的封装性
在访问本类的其它方法，this.方法();
<6.继承的基本概念
        扩展已有类的内容 父类成为超类 super class\
        子类也称派生类
    class 子类 
class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}
class Student extends Person{
    private String School;
    public void setSchool(String school){
        this.School=school;
    }
    public String getSchool(){
        return this.School;
    }
}
public class Text {
    public static void main(String[]args){
        Student stu=new Student();
        stu.setName("王琪");
        stu.setAge(30);
        stu.setSchool("辽宁工大");
        System.out.println("姓名"+stu.getName());
        System.out.println("年龄"+stu.getAge());
        System.out.println("学校"+stu.getSchool());
    }
}
  在java中不允许多重继承：一个子类只能继承继承一个父类 ，
  不能继承多个父类
  在java中允许多层继承
 *在继承中子类不能直接访问父类的私有方法，只能继承全部的公共操作
 例如：
 class A{
         private String name="王琪";
         public String getName(){
                 return this.name;
             }
     }
 class B extends A{
         public static void main(String[]args){
                 B b=new B();
                 System.out.println("姓名"+b.getName()); 
             }
     }
2.构造方法的继承调用
        package dom;
class myperson{
    private String name;
    private int age;
    public myperson(){
        System.out.println("****");
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}
class student extends myperson{
    private String school;
    public student(){
        System.out.println("##");
    }
    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
    
}
public class text2 {
    public static void main(String[]args){
        student stu=new student();
    }
}
    所以关于父类与子类的构造方法：先执行的是父类的午餐的构造方法（如果没有定义，编译的时候也会出现错误）
    最后才调用子类的构造方法
    调用构造方法的目的是为类中的属性初始化所以先调用父类的内容，为父类初始化
    最后的出口一定是父类的构造方法
    
<5.方法的覆写
   方法的覆写是发生在继承的关系中，子类覆写了父类中的相关方法。？？？
   子类定义了与父类同名的方法，称为方法的覆写，在方法的覆写的时候一定要注意访问权限的问题
   被覆写的方法不能拥有比子类更严格的访问权限
   关于访问的权限现在已经学过三种了：private public default 权限小到大的划分 private<default<public
   所以 如果现在在父类中使用的是public 访问权限 则子类覆写的权限只能是public 而不是其他的权限都小于public
  class A{
          public void funO(){
                  System.out.println("A]");
              }
      }
  class B extends A{
          public void fun (){
                  System.out.println(B]);
              }
      }
  class Text(){
          public static void main(String[]args){
                  B b=new B();
                  b.fun();//得到的是被子类覆写的方法
              }
      }
  **********
package dom;
class A{
    public void fun(){
        System.out.println("A]");
    }
}
class B extends A{
    void fun(){//Cannot reduce the visibility of the inherited method from A访问权限问题
        System.out.println("B]");
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.fun();//没得到的是被子类覆写的方法
    }
//int B cannot override fun() in A attempting 
//to weak access privileges 权限
}
注意 只要使用了子类实例化对象，调用的方法也被复写过的化
永远调用的是子类的方法
package dom;
class A{
    public void fun(){
        System.out.println("A]");
    }
    public void print(){
        this.fun();
    }
    
}
class B extends A{
    public void fun(){//Cannot reduce the visibility of the inherited method from A
        System.out.println("B]");
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.print();//得到的是被子类覆写的方法
    }
}
B]
**********
package dom;
class A{
    private void fun(){
        System.out.println("A]");
    }
    public void print(){
        this.fun();
    }
    
}
class B extends A{
    public void fun(){//重新定义
        System.out.println("B]");
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.print();//得到的是新建的的方法
    }
}
A]
*********************************8
package dom;
class A{
    private void fun(){
        System.out.println("A]");
    }
    public void print(){
        this.fun();
    }
    
}
class B extends A{
    public void fun(){
        System.out.println("B]");
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.print();//引用的父类的方法
        b.fun();//引用的是子类的方法
    }
}
A]
B]
*************888
package dom;
class A{
    public void fun(){
        System.out.println("A]");
    }
    public void print(){
        this.fun();
    }
}
class B extends A{
    public void fun(){
        super.fun();//想调用父类中的fun方法必须用关键字super，否则会出现
        //java.lang.StackOverflowError栈溢出
        System.out.println("B]");
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.print();//得到的是被子类覆写的方法
    }
}
A]
B]

<6
java中属性的覆盖
package dom;
class A{
    public String name="hello";
}
class B extends A{
    public String name="nihao";
    public void print(){
        System.out.println("name:"+name);//隐含着this
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.print();//得到的是本类中的属性
    }
}
name:nihao
*********************
package dom;
class A{
    public String name="hello";
}
class B extends A{
    public int name=59;//覆写的时候可以转换类型的
    public void print(){
        System.out.println("name:"+name);//隐含着this
    }
}
public class Text{
    public static void main(String[]args){
        B b=new B();
        b.print();//得到的是本类中的属性
    }
}
name:59
但是在实际开发中属性是private所以腹泻时无法实现的

<7方法覆写的应用
package dom;
class myperson{
    private String name;
    private int age;
    public myperson(){}
    public myperson(String name, int age){
        this.setName(name);
        this.setAge(age);
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String toString(){
        return "姓名"+this.getName()+"年龄"+this.getAge();
    }
}
class student extends myperson{
    private String school;
    public student(String name,int age,String School){  
        super(name,age);
        this.setSchool(School);
    }
    public String getSchool() {
        return school;
    }
    public void setSchool(String school) {
        this.school = school;
    }
    public String toString(){//!!!!!!!!这里使用到了方法的覆写!!!!!!!!!!!!!
        return super.toString()+"学校"+this.getSchool()+"!";
    }//!!!!!!!!!!!!!!!!!!!!!!!!!!!!简化方法的操作!!!!!!!!!!!!!!!!!!!!!!!!!
}
public class text2 {
    public static void main(String[]args){
        student stu=new student("张三",30,"清华大学");
        System.out.println(stu);
    }
}
//此事代码没有多余的操作，而达到代码的重用