面向对象程序设计

• 面向过程->开发效率低，维护成本高；面向对象->忽略过程中的细节，事物模块化
• 类和对象

public class 类名{
    //定义属性，属性名（驼峰式）
    public 数据类型 属性名;
        //定义方法
    public 返回值类型 方法名(数据类型 参数名){
        //方法体
    }
}

构造方法（构造函数；构造器）

class Student{
    public String name;
    public int ID;
public Student(String N,int i){//构造方法（有参构造）
    name=N;
    ID=i
}
public void ChangeName(String NewName){//普通方法
    name=NewName;
}
    
}

public void PrintInfo(String...args){  // Java特有的方式，代表0到多个参数
    for(int i=0;i<args.length>
public class Test{
    public static void main(String[] args){
        Person p=new Person();
        String[] a=new String[]{"1","woshidage","2333"};
        p.PrintInfo(args);
    }
}
	

		

	
	

		方法的参数传递
	
	

		方法必须有其所在类或对象调用才有意义，含有（形参：方法声明时的参数；实参：方法调用时实际传给形参的参数值）

	
	

		Java例方法的参数传递只有值传递

	
	

		 如果方法的形参是基本数据类型，那么实参（实际的数据）向形参传递参数时，就是直接传递值，把实参的值复制给形参
	
	

		如果方法的形参时对象，那么实参（实际的对象），向形参传递参数的时，也是把值传给形参，这个值是实参在栈内存中的值，也就是引用对象在堆内存中的地址
	
	

		基本数据类型都是保存在栈内存中，引用对象在栈内存中保存的是引用对象的地址，那么方法的传递参数是传递值（变量在栈内存中的值） 

	
</args.length>

        this();//调用无参构造方法，实现同一个类中构造方法相互调用的特殊格式（禁止套娃：无法同时相互调用；调用自身）

static{
    System.out.print(1);
}

继承

public class 类名 extends 父类名{    //子类 is a 父类
    
}

public Student(){
    super(参数);
    System.out.println("通过无参构造创建了Student对象");
}

构造方法：super();
普通方法：super.方法名(参数列表);
成员变量：super.成员变量名;

public class Test{
    public void test(Object obj){
        //不确定传进来的类，可以确定传递实参一定是个类
    }
    public static void main(String[] args){
        Test t=new Test();
        Person p=new Person();
        Student s=new Student();
        t.test(p);
        t.test(s);
    }
}

对象类型转换

int i=20;
double d=i; // 自动类型转换

long l=10l;
int i=(int)l; // 强制类型转换

Java对象的强制类型转换（造型）

public void method(Person e){
    if(e instanceof Student){
        Student s=(Student) e;
        s.getschool();
    }else{
        e.test();
    }
}

int i=3;
System.out.println(i == 4); // false

Person p1 = new Person();
Person p2 = new Person();
System.out.println( p1 == p2 ); // false

Person p1 = new Person();
Person p2 = p1;
System.out.println( p1 == p2 ); // true

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println( s1 == s2 ); // false
System.out.println( s1.equals(s2) ); // true

 // 字面量创建String对象
String s1 = "abc"; // 常量池添加"abc"对象，返回引用地址给s1
String s2 = "abc"; // 通过equals方法判断常量池已有，返回相同引用
System.out.println( s1 == s2 ); // true


 // new创建String对象，一定会创建新对象，地址不重复

String s3 = "x" + "y"; // 在常量池中添加"xy"对象
String s4 = new String("1") + new String("2"); // 在常量池中添加"1"和"2"两个对象，在堆中创建为"12"的对象，再引用地址

int i = 500 ;
Integer t = new Integer( i );
Float f = new Float("4.56");
Long l = new Long("asdf"); // 报错

// 调用包装类的.xxxValue()方法;
Integer i = new Integer(111); // Integer i = 111  自动装箱然后赋值
System.out.println(i); // 111（自动拆箱然后输出）
int i0 = i.intValue(); // 拆箱

boolean b = new Boolean( "false" ).booleanValue(); // boolean b = new Boolean( "false" );  自动拆箱
Boolean B = true; // 自动装箱
System.out.println( b ); // false

// 主要应用：

Integer i = Integer.parseInt("123");
Float f = Float.parseFloat("0.40");
Boolean b = Boolean.parseBoolean("false"); // 字符串转换成基本数据类型  String istr = String.valueOf(i); // 基本数据类型转换成字符串

toString

public String toString(){
    String str = this.getName() + " " + this.getAge();
    return str;
} // toString方法重写，用于打印对象

public void toString(){
    System.out.println( this.getName() + " " + this.getAge );
} // 另一种形式

static关键字

public class Chinese{
    public String name;
    private int age;
    public String country; // static String country;  country为类变量(静态变量)

        public static void Test(){
            System.out.println("这是一个静态方法");
        }
}

public class Main{
    public static void main(String[] args){
     // Chinese.country = "China";
        Chinese c1 = new Chinese();
        c1.country = "China"; // 可以注释掉
        Chinese c2 = new Chinese();
        c2.country = "China"; // 可以注释掉
     // System.out.println(Chinese.country);  直接通过类名设置和访问
    }
}

单例（Singleton）设计模式

public class Single{
    public Single(){
        // 假设构造中执行复杂代码（耗时很长）
    } // 适合使用单例模式
}

实现方式—饿汉式

public class Single{
    private Single(){
        
    } // 构造方法私有化，调用类时无法使用new创建对象

private static Single s = new Single(); // 私有的Single类型的类变量，只有一个

public static Single getInstance(){
        return s;
    } // 使用已定义的类变量
}

public class Single{
    private Single(){
        // 私有化构造
    }
    
    private static Single s = null; // 将s初始化为空
    
    public static Single getInstance(){
        if( s == null ){
            s = new Single(); // 第一个实例化时定义对象
        }
        return s;
    }
}

public class TestMain{
    public static void main(String[] args){
        for(int i=0,i<args.length>
	

		
	

	

		模板方法设计模式
	

	

		抽象类是子类的通用模板 
	

	

		把不确定的功能内部实现暴露出去让子类实现
	

	

		
	

	

		final关键字
	

	

		final修饰的类无法被继承 // public final class Test { }
	

	

		final修饰的方法不能被子类重写 // public void Test () { }
	

	

		final修饰的变量称为常量，只能被赋值一次 // final static int I = 0; 定义时完成赋值，final和static共同修饰为全局常量
	
// 常量定义名称使用大写，多个单词用 _ 连接
 </args.length>

class A{ // 泛型T可以任意取名，一般使用T（type）
    private T key;
    
    public void setKey(T key){
        this.key = key;
    }
    public T getKey(){
        return this.key;
    }
}

Aa = new A(); // 在new对象中指定泛型类型String
a.setKey("xxx"); // 对象使用中key的类型为String
String a1 = a.getKey(); // t.getKey返回值类型也是String

Aa2 = new A();
a2.setKey(1);
Integer i = a2.getKey();  //  <>中如果没写就是Object类型

泛型接口

public interface IB{
    public T test(T key);
}
 // 未传入实际泛型
public class B1implements IB{
    public T test(T t){
        return t;  //  B1b1 = new B1();
    }
}

public class B2 implements IB{
    public String test(String t){
        return t;    //    B2  b2  =  new B2();
    }
}

public class C{
    publicvoid main(T s){
        T t = s;
    }
    
    public String void test1(String s){
        return s;
    }
}