面向对象下

/**
    继承:继承是从已有的类创建新类的过程。
    继承一个父类，只能继承非私有的数据（属性和方法）
    protected访问权限修饰符，在继承关系中使用，在父类中使用protected修饰的属性或方法可以被子类继承
    创建子类对象时，父类的构造方法也会被调用，为什么？
    因为子类要使用到父类的数据，那么就要通过父类的构造方法来初始化数据
    //如果创建子类对象时使用默认的构造方法，那么父类的默认构造方法也会被调用
    如果创建子类对象时会调用父类的默认构造方法
    
    当父类中没有无参构造方法时，子类必须显示的调用父类的带参构造方法，怎么调用呢？
    可以在子类中显示的使用super(...)调用父类的构造方法，只能出现在第一句
    
    面试题 ：overloading与overriding的区别？
    overloading:方法的重载，发生在同一个类中，方法名相同，参数列表不同，返回值无关。
    overriding：方法的重写，发生在子父类中，方法名相同，参数列表相同，返回值相同，子类的访问修饰符要大于或等于父类
    的访问修饰符，子类的异常声明必须小于或等于父类的异常声明。如果方法被private,static,final修饰，那么不能被重写

*/
public class Test1{
    public static void main(String[] args){
    
        HomeDog homeDog = new HomeDog("旺财");
        homeDog.print();
        homeDog.eat();
        
        HuskyDog hd = new HuskyDog();
        hd.eat();
    
    }
}

class Dog{
    protected String name;
    private String sex;
    public Dog(String name,String sex){
        this.name = name;
        this.sex = sex;
        System.out.println("我是Dog的构造方法");
    }
    protected void eat(){
        System.out.println("吃饭");
    }
}
class HomeDog extends Dog{
    public HomeDog(String name){
        super(name,"公");//只能在第一句
        System.out.println("我是HomeDog的构造方法");
    }
    protected void print(){
        //super.属性 表示调用父类的属性,如果是继承过来的属性，那么super可以省略
        System.out.println(super.name+"我是一只家狗,wangwang");
    }
    //重写父类的方法
    public void eat(){
        super.eat();//调用父类的方法
        System.out.println("我是家狗，我喜欢吃骨头");
    }
    
}

class HuskyDog extends Dog{
    public HuskyDog(){
        super("哈士奇","母");
        System.out.println("我是HuskyDog的构造方法");
    }
    public void show(){
        System.out.println(name+"我是husky，我能跳舞");
    }
    public void eat(){
        System.out.println("我是husky，我喜欢吃鸡肝");
    }
}

 

---

---

/**
     final关键字
     1、使用final声明一个属性，就是常量，常量的命名规则建议使用全大写,常量必须在定义时或在构造器中初始化
     2、使用final声明的方法，不能被子类重写，只能被继承
     3、使用final关键字声明一个类，该类就转变为最终类，没有子类的类，fianl修饰的类无法被继承。
*/
public class Test3{
    
    public static void main(String[] args){
    
        System.out.println(Constant.PERSON_NUM);
        
        FinalClass fc = new FinalClass();
        fc.setLength(10);
    }
}

//常量类(工具类):在实际项目开发中，常量类通常用于定义项目中一些公共的，不变的，数据

final class Constant{
    public static final int PERSON_NUM = 10; //人数
    public static final String SERVER_ROOT_URL = "http://www.baidu.com";
    public static final String CACHE_PATH = "data_cache";

}

class FinalClass{
    public final int DAY_NUMBER;//工作天数
    
    public FinalClass(){
        DAY_NUMBER = 22;
    }
    
    public final void print(){
        System.out.println("我是final方法");
    }
    
    public void setLength(final int size){
        final int x = 20;
        size++;
        System.out.println(size);
    }
}

class SubClass extends FinalClass{
    /*public void print(){
        System.out.println("我是final方法");
    }*/
}

 

  

/**
    抽象类:用abstract关键字声明的类称为抽象类，
    很多具有相同特征和行为的对象可以抽象为一个类，
    很多具有相同特征和行为的类可以抽象为一个抽象类
    
1、抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
2、非抽象类继承抽象类必须实现所有抽象方法
3、抽象类可以继承抽象类，可以不实现父类抽象方法。
4、抽象类可以有方法实现和属性
5、抽象类不能被实例化
6、抽象类不能声明为final
7、抽象类可以有构造方法

    
*/
public class Test4{
    public static void main(String[] args){
        Man man = new Man();
        man.move();
        man.eat();
        
        Women women = new Women();
        women.move();
        women.eat();
        
        //Animal a = new Animal();
        
    }
}

abstract class Animal{
    public abstract void move();//方法的声明，抽象方法只有声明，没有实现
    
}

abstract class Person extends Animal{
    public abstract void eat();
    public void sleep(){
        System.out.println("睡觉");
    }
}

//继承抽象类的具体类必须实现所有抽象方法
class Man extends Person{
    
    public void move(){
        System.out.println("我是男人，我爱跑步");
    }
    public void eat(){
        System.out.println("我是男人，我爱吃肉");
    }
}

class Women extends Person{
    public void move(){
        System.out.println("我是女人，我爱逛街");
    }
    public void eat(){
        System.out.println("我是女人，我爱吃香蕉");
    }
}

---

 

\

---

/*
 * OO设计原则：
 * 
 * 1、面向接口编程（面向抽象编程）
 * 
 * 2、封装变化 ex:save方法是可以变的，单独拿出来封装
 * 
 * 3、多用组合，少用继承；继承的多那么重写的方法就会很多，继承少慎用
 * 
 * 
 * 
 * 把可变的行为抽象出来，这样的好处是这些行为可以在真正使用时
 * 
 */

public class Test8 {
    public static void main(String[] args) {
        BaseService user = new UserService();
        //user.setISave(new FileSave());
        user.setISave(new NetSave());
        user.add("user");
    }
}

//把可变的行为抽象出来，定义一系列的算法
//↓↓↓↓↓↓↓↓↓↓↓↓↓111111111111↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
//==========================================================
interface ISave{
    //可变的是save，把可变的东西单独拿出来封装，这就是封装变法
    public void save(String data);
}

class FileSave implements ISave{
    public void save(String data) {
        System.out.println("把数据保存到文件中..." + data);
    }
}

class NetSave implements ISave{
    public void save(String data) {
        System.out.println("把数据保存到网络上..." + data);
    }
}
//============================================================

//↓↓↓↓↓↓↓↓↓↓↓↓↓22222222222222↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
abstract class BaseService{
    //BaseService来组合ISave
    //把接口作为类的属性来定义，然后提供一个set方法或者是构造方法都行
    private ISave iSave;
    public void setISave(ISave iSave) {
        this.iSave = iSave;
    }
    
    public void add(String data) {
        System.out.println("检查数据合法性...");
        iSave.save(data);
        System.out.println("数据保存完毕...");
    }
}

class UserService extends BaseService{
    //UserService到main里面
}

---

 

/**
    Object对象
*/
public class Test9{
    public static void main(String[] args){
        Student s = new Student(1,"飞飞",18);
        System.out.println(s);
        Student s2 = new Student(1,"飞飞",18);
        boolean b = s.equals(s2);
        System.out.println("student equals "+b);
        
        String str1 = new String("备备");
        String str2 = new String("备备");
        System.out.println(str1.equals(str2));
        
        System.out.println(s.getClass()==s2.getClass());
        
    
    }
}

class Student{
    private String name;
    private int sid;
    private int age;
    public Student(){}
    public Student(int sid,String name,int age){
        this.sid = sid;
        this.name = name;
        this.age = age;
    }
    //重写Object类中的toString方法
    public String toString(){
        return "sid="+sid+",name="+name+",age="+age;
    }
    
    //重写equals方法，来实现两个对象的比较
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if(obj instanceof Student){
            Student s = (Student)obj;
            if(!this.name.equals(s.name)){
                return false;
            }
            if(this.sid!=s.sid){
                return false;
            }
            if(this.age!=s.age){
                return false;
            }
            return true;
        }
        return false;
    }
}

/* public class Test10{
    public static void main(String[] args){
        //使用者和被使用者两者之间，耦合，产生了依赖，当 被使用者 改变时，会影响使用者
        //使用工厂模式来降低两者之间的依赖
        Product phone = new Phone();
        phone.work();
    }
}


interface Product{
    public void work();
}

class Phone implements Product{
    public void work(){
        System.out.println("手机开始工作...");
    }
}

class Computer implements Product{
    public void work(){
        System.out.println("电脑开始工作...")
    }
} */

//简单的工厂设计模式：

public class Test10{
    public static void main(String[] args){
        //使用者和被使用者两者之间，耦合，产生了依赖，当 被使用者 改变时，会影响使用者
        //使用工厂模式来降低两者之间的依赖
        //Product phone = new Phone();
        Product phone = ProductFactory.getProduct("phone");
        if(null!=phone){
            phone.work();
        }
    }
}

//工厂类：
class ProductFactory{
    public Product getProduct(String name){
        if("phone".equals(name)){
            return new Phone();
        }else if("computer".equals(name)){
            return new Computer();
        }else{
            return null;
        }
    }    
}

interface Product{
    public void work();
}

class Phone implements Product{
    public void work(){
        System.out.println("手机开始工作...");
    }
}

class Computer implements Product{
    public void work(){
        System.out.println("电脑开始工作...")
    }
}

---

 

/**
    代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。
    代理模式说白了就是“真实对象”的代表，在访问对象时引入一定程度的间接性，
    因为这种间接性可以附加多种用途。

*/
public class Test11{
    public static void main(String[] args){
        Action userAction = new UserAction();
        ActionProxy proxy = new ActionProxy(userAction);
        proxy.doAction();
    }
}

class ActionProxy implements Action{
    
    private Action target;//被代理的对象
    
    public ActionProxy(Action target){
        this.target = target;
    }
    
    //执行操作
    public void doAction(){
        long startTime = System.currentTimeMillis();
        
        target.doAction();//执行真正的业务
        
        
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时："+(endTime-startTime));
    }
} 

interface Action{
    public void doAction();
}

class UserAction implements Action{
    public void doAction(){
        for(int i=0;i<100;i++){
            System.out.println("用户开始工作...");
        }
        
    }
}

---

/* public class Test12{
    public static void main(String[] args){
        PowerA powerA = new PowerA();
        work(powerA);
    }

    public static void work(PowerA a){
        System.out.println("正在连接...");
        a.insert();
        System.out.println("工作结束...");
    }
}

interface PowerA{
    public void insert();
}

class PowerAImpl implements PowerA{
    public void insert(){
        System.out,println("电源A开始工作");
    }
} */

//==================================================

public class Test12{
    public static void main(String[] args){
        PowerA powerA = new PowerAImpl();
        //work(powerA);
        
        PowerB powerB = new PowerAImpl();
        //work(powerB);
        Adapter adapter = new Adapter(powerB);
        work(adapter);
        
    }

    public static void work(PowerA a){
        System.out.println("正在连接...");
        a.insert();
        System.out.println("工作结束...");
    }
}

//适配器
interface Animal{
    public void sing();
    public void cry();
    public vodi run();
    public void swim();
}

abstract class AnimalFunction{
    public void sing(){}
    public void cry(){}
    public vodi run(){}
    public void swim(){}
}


class Dog extends AnimalFunction{
//class Dog implements Animal{
    public void sing(){}
    public void cry(){}
    public vodi run(){
        System.out.println("我是疯狗,疯狂的跑");
    }
    public void swim(){}
}


//适配器：====================================
class Adapter implements PowerA{
    private PowerB powerB;
    public Adapter(PowerB powerB){
        this.powerB = powerB;
    }
    public void insert(){
        powerB.connect();
    }
}
//===========================================

interface PowerB{
    public void connect();
}
class PowerBImpl implements PowerB{
    public void connect(){
        System.out.println("电源B开始工作");
    }
}

interface PowerA{
    public void insert();
}

class PowerAImpl implements PowerA{
    public void insert(){
        System.out,println("电源A开始工作");
    }
}

---

 

自动生成两个class文件

/*
内部类
    1、成员内部类：直接在类中定义的类
    2、方法内部类：在一个类中的方法内定义一个类
        (1)方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化
        (2)方法内部类对象不能使用该内部类所在方法的非final局部变量。
    3、静态内部类，在类中定义一个静态修饰的内部类，
        静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。
        静态嵌套类仅能访问外部类的静态成员和方法。
    4、匿名内部类就是没有名字的内部类。
        匿名内部类的三种情况：
        （1）继承式的匿名内部类
        （2）接口式的匿名内部类
        （3）参数式的匿名内部类
//*///

/* public class Test13{
    public static void main(String[] args){
        
        Outer outer = new Outer();
        //在外部创建成员内部类的实例，因为成员内部类需要依赖外部类的对象;
        //通常情况下,我们不建议这样来实例化内部类的对象↓
        Outer.Inner inner = outer.new Inner();
        inner.print();
        
    }
}

class Outer{
    
    private String name;
    
    //成员内部类
    class Inner{
        public void print(){
            System.out.println("inner");
        }
    }
    
} */


//=========================================================================
public class Test13{
    public static void main(String[] args){
        
        Outer outer = new Outer();
        //在外部创建成员内部类的实例，因为成员内部类需要依赖外部类的对象;
        //通常情况下,我们不建议这样来实例化内部类的对象↓
        /* Outer.Inner inner = outer.new Inner();
        inner.print(); */
        
        //改进：↓
        outer.innerPrint();
    }
}

class Outer{
    
    private String name;
    //建议再外部类中定义一个方法,对外提供访问内部类的接口：
    //改进：↓
    public void innerPrint(){
        Inner inner = new Inner();
        inner.print();
    }
    
    //成员内部类
    //改进：↓本来是class Inner变成私有的:private class Inner
    private class Inner{
        public void print(){
            System.out.println("inner");
        }
    }
    
}

---