java的面向对象基础知识下

一：包装类的使用

---

String类型转化为基本数据类型、包装类:调用包装类的parseXxx()方法。

@Test
	public void test5() {
		String str1 = "123";  //只能写数字若写123a就会报错.
		//可能会报NumberFormatExceptioon错误
		int num2 = Integer.parseInt(str1);//将字符型的123转化为int型的123；
		System.out.println(num2 + 1);
		
		String str2 = "true1"; //写的如果不是true就报flase了
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
		
		String str3 = "12.5";
		double d1 = Double.parseDouble(str3);
		System.out.println(d1);
		
	}

---

基本数据类型、包装类------->String类型调用String的valueOf(xxxx)

@Test
	public void test4() {
		int num1 = 10;
		//方式一：连接运算
		String str1 = num1 + "";
		//方式2：调用String的valueOf(xxxx)
		
		Float f1 = 12.3333f;
		float f2 = f1.floatValue();
		String str2 = String.valueOf(f1);//将字符型转化为String类型
		System.out.println(str2);
		System.out.println(str2.length());
		
		int d1 = 10;
		Integer d2 = 10;
		String str3 = String.valueOf(d1);
		String str4 = String.valueOf(d2);
		System.out.println("shifpi");
		System.out.println(str3.length() == str4.length() );
		
		
		//Double d1 = new Double(12.4);//此时d1为新创建的一个包装类
	//	int d2 = d1.intValue();
	//	double d3 = d2;
		//String str3 = String.valueOf(d2);//此处自动拆箱，所以可以把d1直接放进去
		System.out.println(str3);
		
	}
	

---

二：静态代码块的使用

类的成员之四：代码块 1.代码块的作用：用来初始化类、对象 2.代码块如果有修饰的话，只能使用static 3.分类：静态代码块
 *       vs非静态代码块
 *
 *
 *       4.静态代码块 》内部可以有输出语句
 *                   》随着类的加载而执行
 *                   》作用：初试化类的信息
 *                   》如果一个类中定义多个静态代码块，则按照声明的先后顺序执行
 *                   》静态代码块的执行要优先于非静态代码块的执行
 *                   》静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构.
 *
 *
 *       5.非静态代码块
 *
 *       》内部可以有输出语句
 *       》随着对象的创建而执行
 *       》每创建一个对象，就会执行一次非静态代码块
 *       》作用：可以在创建对象时，对对象属性等进行初始化
 *       》如果一个类中定义了多个非静态代码块，则按照声明的先后顺序进行执行。
 *       》非静态代码块可以调用静态的属性、静态的方法，或非静态的属性，非静态的方法.
 *       
 *       >作用：可以在创建对象时，对对象的属性等进行初始化
 *       
 *       对象属性可以赋值的位置
 *       ①默认初始化
 *       ②显式初始化/⑤可以在代码块中赋值:看谁先写，谁先写谁就先赋值
 *       ③构造器初始化
 *       ④有了对象后，可以通过“对象.属性”或“对象.方法进行赋值
 *      
 *      执行的先后顺序:
 *       
 *

 执行的先后顺序：由父即子  静态先行
 * 
 * 所谓由父即子：是先加载父类的静态代码块，然后在加载子类的静态代码块
 * 
 * 在创建对象时，先加载父类非静态代码块，然后加载父类构造器，（在同一个类中，代码块的加载，要先于构造器）最后在加载子类非静态代码块
 * 子类构造器。
 * 
 */

public class Son extends Father{
	
	static {
		System.out.println("444444444444444444");
	}
	{
		System.out.println("555555555555555555555");
	}
	
	public Son() {
		super();
		System.out.println("66666666666666666");
	}
	
	public static void main(String[] args) {
		//main是静态方法，也要通过类去调用，在调用类前，需要先加载类
		System.out.println("777777777777777777");
		System.out.println("***********************");
		new Son();
		System.out.println("**************************");
		new Son();
		System.out.println("*********************");
		new Father();
	}
	

}


class Father{  
	static { //在加载类的时候执行
		System.out.println("1111111111111111111");
	}
	public Father() {
		System.out.println("333333333333333333333");
	}
	{ //在创建对象时执行
		System.out.println("222222222222222222222");
	}
	
}

三：static和final关键字的使用

1.final可以用来修饰类的结构：类、方法、变量
 *
 * 2.final 用来修饰一个类：此类不能被其他类所继承
 *
 * 3.final 用来修饰方法：表示此方法不可以被重写
 * 比如：Object类中getClass();
 * 4.final 用来修饰变量：此时“变量”就称为是一个常量
 *   4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
 *   4.2 final修饰形参时，表名此形参是一个常量。当我们调用此方法时，给常量形参赋一个值，一旦赋值以后，以后就
 *   只能在方法体内使用此形参，但不能进行重新赋值。
 *   
 *   static final：用来修饰属性：全局常量,变量必须在定义时进行初始化。

1.static 静态的
 * 2.static可以用来修饰：属性、方法、代码块、内部类
 *
 * 3.使用static修饰属性：静态变量（类变量）
 *   3.1 属性，按是否使用static修饰，又分为：静态属性 vs非静态属性（实例变量）
 *   实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改
 *   
 *   静态变量:我们创建了类的多个对象，多个对象共同享用一个静态变量。当通过某一个对象修改静态变量时，会导致
 *  其他对象调用此静态变量时，是修改过了的。
 *   3.2 static修饰属性的其他说明
 *     ①静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用
 *     ②静态变量的加载要早于对象的创建
 *     ③由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中.
 *     
 *      ④    类变量       实例变量（      表示是否可以被调用          )
 *      类      yes       no
 *      对象     yes        yes
 *      
 *      3.3静态属性举例：System.out.print   Math.PI;
 *      
 *      4.使用static修饰方法：静态方法  
 *       ①：随着类的加载而加载，可以通过“类.静态方法”的方式进行调用
 *       
 *            静态方法       非静态变量
 *      类      yes        no
 *      对象     yes        yes
 *      
 *      ③：非静态方法中。既可以调用个非静态的方法或属性，也可以调用静态的方法或属性
 *      
 *      
 *      5.static注意点
 *        5.1 在静态方法内，不能使用this关键字、super关键字
 *        
 *        5.2 关于静态属性和方法的使用，可以从生命周期的角度去理解.
 *        
 *        开发中.如何确定一个属性是否要声明为static的？
 *        》属性是可以被多个对象所共享的，不会随着对象的不同而不同
 *        
 *        
 *        开发中，如何确定一个方法是否要声明为static的？
 *        》操作静态属性的方法，通常设置为static
 *        》工具类中的方法，习惯上为static的，比如Math、Array、Collections
 *        
 *      

---

四：abstract关键字的使用

abstract关键字的使用
 * 1.abstract：抽象的
 * 2.abstract可以用来修饰的结构：类、方法

抽象方法不能用private、final、static、native修饰
 *
 * 3.abstract修饰类：抽象类
 *   >此抽象类不能够实例化
 *   >抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化全过程）.
 *   >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

     java中抽象类可以有非抽象方法、抽象方法
 *   
 *   
 *   
 *   4.abstract修饰方法：抽象方法
 *     >抽象方法只有方法的声明，没有放方法体。
 *     >包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法。
 *     >若子类重写了父类中的所有抽象方法后，此子类方可实例化
 *     若子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

 *     
 抽象类的应用，模板方法：

//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {
	
	public static void main(String[] args) {
		
		BankTemplateMethod bank1 = new DrawMoney();//因为父类是抽象类，所以必须通过子类才能够实例化。
		 DrawMoney draw = new DrawMoney();
		draw.process();//子类中没有的方法，在执行的过程中，去父类中，一级一级往上找。调用的是父类中的方法
		
		 bank1.process();//此处体现的多态，执行的是子类重写的方法。
		
		
	}

}


abstract class BankTemplateMethod{// 抽象类不能够实例化，必须通过其继承的子类才能够实例化。
	//具体方法
	public void takeNumber() {
		System.out.println("取号排队");
		
	}
	
	public abstract void transact();//办理具体业务//钩子方法
	
	
	public void evaluate() {
		System.out.println("反馈评分");
	}
	
	//模板方法，把基本操作组合一起，子类一般不能重写
	
	public final void process() { //通过final关键字，说明此方法不能够被重写了
		this.takeNumber();
		
		this.transact(); //像个钩子，具体执行时，挂哪个类，就执行哪个子类的实现代码
		
		this.evaluate();
		
		
	}
	
	
	
	
}



class DrawMoney extends BankTemplateMethod{ //重写父类的方法，只有一个方法必须需要重写。
	
	public void transact() {
		System.out.println("我要取款");
		
	}
	
}



class MangeMoeny extends BankTemplateMethod {
	public void transact() { //重写父类中的抽象方法.
		System.out.println("我要理财！我这里有200000万美元");
	}
}

---

五：java中接口的使用

*
 *接口的使用：
 *1.接口使用interface定义
 *2.java中，接口和类是并列的两个结构
 *3.如何定义接口：定义接口中的成员
 *   3.1 JDK7及以前：只能定义全局常量和抽象方法
 *    >全局常量：public static final的。但是书写时，可以省略不写
 *                全局常量在定义的时候就要初始化.
 *    >抽象方法 ：public abstract的
 *    
 *    
 *    3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
 *    
 *    
 *    4接口中不能定义构造器的！ 意味着接口不可以实例化,
 *    
 *    
 *    5.Java开发中，接口可以让类去实现(implements)的方式来使用
 *    如果实现类覆盖了接口中所有抽象方法，则此实现类可以实例化
 *    如果实现类没有覆盖接口中所有抽象方法，则此类仍为一个抽象类
 *    
 *    6.Java类可以实现多个接口---》弥补java单继承的局限性
 *    格式：class AA extends BB implements CC,DD,EE
 *    
 *    7.接口与接口之间可以继承，而且可以多继承
 *    
 *    **************************************
 *    8.接口的具体使用体现多态性
 *    9.接口，实际上可以看做是一种规范
 *    接口是对方法 的一种规范
 *    
 *    接口的修饰符可以是public或省略
 *    接口里所有成员都是public
 *    接口不能创建实例，但是可以声明变量
 *    接口就是一种公共的规范标准，只要符合规范标准，大家都可以用
 *   

public class Interview {
	/**
	 * 定义在接口中的都是被public  final static修饰的，一旦定义就不能够修改.
	 */
	

}

interface Playable{
	void play();
}

interface Bounceable{
	void play();
}

interface Rollable extends Playable,Bounceable{
	Ball ball = new Ball("pingpang"); //定义在接口里的都是被public final static修饰的，一旦定义就不能
	//在修改了。
}
class Ball implements Rollable{
	private String name;
	public String getName() {
		return name;
	}
	public Ball(String name) {
		this.name = name;
	}
	
	public void play() {
	//	ball = new Ball("football"); //不能够在修改了
		System.out.println(ball.getName());
	}
}

jdk8接口中的新特性：

JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

public class SuperClass {
	public void method3() {
		System.out.println("SuperClass:重庆");
		
	}

}

public class SubClassTest  {
	public static void main(String[] args) {
		SubClass s = new SubClass();
		
		//s.method1();
		//知识点1：接口中定义的静态方法，只能通过接口来调用
		
		//s.method2();
		//知识点2：通过实现类的对象，可以调用接口中的默认方法
		//如果实现类中重写了接口中的方法，调用时，仍然调用的是重写后的方法
		
		s.method3();
		//知识点3：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法
		//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法
		
		
		
		//CompareA.method1();//接口中的静态方法通过，接口来调用
		
		
	}
	

}

class SubClass extends SuperClass implements CompareA,CompareB{
	
	//知识点4：如果实现类中实现了多个接口，而这多个接口定义了同名同参数的默认方法，
	//那么在实现类没有重写此方法的情况下，报错----》接口冲突
	//这就需要我们必须在实现类中重写此方法
	//这是在没有父类的情况下，不重写会起接口冲突，有父类的情况下默认调用父类中的方法。
	
	public void method2() {
		System.out.println("SubClass:上海");
	}
	
	public void method3() {
		System.out.println("SubClass；深圳");
	}
	//知识点5.如何在子类（或实现类）的方法中调用父类、接口中被重写的方法。
	public void myMethod() {
		method3();//调用自己定义的重写方法
		super.method3(); //调用的是父类中声明的方法
		CompareA.super.method3();  //调用接口中的默认方法
		}
	
}

---

java内部类的使用

 类的内部成员之五：内部类
 * 1.Java中允许一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
 * 2.内部类的分类：成员内部类（静态、非静态） vs 局部内部类（方法内、构造器内）
 *
 * 3.成员内部类
 *     一方面，作为外部类的成员
 *         >可以调用外部类的结构
 *         >可以被static修饰
 *         >可以被四种不同的权限修饰.
 *         
 *         
 *         
 *         
 *         
 *        另一方面：作为一个类
 *                >类可以定义属性、方法、构造器等
 *                >可以被final修饰，表示此类不能被继承。言外之意，不使用final就可以被继承
 *                > 可以被abstract修饰
 *                
 *         
 *    4.关注三个问题
 *       4.1 如何实例化成员内部类的对象
 *       4.2 如何在成员内部类中区分调用外部类的结构
 *       4.3 开发中局部内部类的使用     
 *       
 *       
 *       
 *       在局部内部类的方法中（比如：show） 如果调用局部内部类所声明的方法(比如：method)中的局部变量
 *       的话，要求此局部变量声明为final的。
 *       
 *       jdk 7及以前版本：要求此局部变量显式声明为final的
 *       
 *       jdk 8及之后的版本：可以省略final的声明
 *    

public class InnerClassTest {
	public static void main(String[] args) {
		//创建Dog实例(静态的成员内部类)
		Person .Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类)
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		System.out.println("********************************");
		p.method();
	}
	
	

}

class Person{
	String name;
	//静态成员内部类
	
		static class Dog{
			String name;
			int age;
			
			public void show() {
				System.out.println("卡拉是条狗！");
			}
			
		}
		
		public void eat() {
			
		}
		
		//非静态成员内部类
		class Bird{
			String name;
			public Bird() {
				
			}
			
			public void sing() {
				System.out.println("我是一只大鹏鸟！");
				Person.this.eat(); //调用Person这个对象的方法
				
			}
			public void display(String name) {
				System.out.println(name); //方法形参
				System.out.println(this.name); //内部类的属性
				System.out.println(Person.this.name); //外部类的属性
			}
			
			
		}
		
		public void method() {
			//局部变量
			 int  num = 10;
			class AA {
				public void show() {
					//num =20;//错误，局部内部类调用的局部变量必须是常量。
					System.out.println(num);
					/**
					 * 被内部类访问的局部变量会被拷贝一份到内部类中，
					 * 即Inner中存在一个成员变量，用于记录局部变量a的值。
					 * 若局部变量不是final的，其取值就可以被修改，
					 * 而Inner对象中保存的是其原来的值，这就会出现数据不同步的问题。

Java为了避免数据不同步的问题，做出了内部类只可以访问final的局部变量的限制。
					 */
				}
				
				
			
			}
			AA  aa = new AA();
			aa.show();
		}
		
		
		
		
		
		
	
}

---

java的异常体系结构

一、异常体系结构
 * java.lang.Throwable
 *             |------java.lang.Error:一般不编写针对性的代码进行处理
 *             |------java.lang.Exception:可以进行异常处理
 *                     |-----编译时异常(checkd)
 *                           |-----IOEException
 *                                 |-----FileNotFoundException
 *                           |------ClassNotFoundException
 *
 *
 *                     |------运行时异常（unchecked）
 *                             |-------NullPointerException
 *                             |-------ArrayIndexOutOfBoundException
 *                             |-------ClassCastException
 *                             |------InputMistmatchException
 *
 *

异常的处理：抓抛模型
 *
 * 过程一、“抛” :程序在正常执行过程中，一旦出现了异常，就会在异常代码处生成一个对应异常类对象。
 * 并将此对象抛出。
 * 一旦对象抛出后，其后的代码就不在执行。
 * 关于异常对象的产生① 系统自动生成的异常对象。
 *                 ②手动生成一个异常对象，并抛出（throw）
 *
 *
 *
 *
 
 *
 *
 *
 * 过程二、“抓”：可以理解为异常的处理方式：①try-catch-finally  ②throws
 *
 *
 *
 *
 * 二、try-catch-finall的使用
 *
 * try{
 *
 *
 *     }catch(异常类型1 变量名1){
          //处理方式一

                           }
    catch(异常类型2 变量名2){

        处理方式二
                           }
                           
        finall{
        
        //一定会执行的代码
        }        
        
    1.说明finally是可选的，不一定非要写
    2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常对象，
    根据此对象的类型，去catch中进行匹配
    3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理，一旦处理完成，就跳出
    当前的try-catch结构（在没有写finally的情况）。继续执行其后的代码
    4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓
    5.常用的异常处理方式：① String getMessage   ②printStackTrace（）打印整个堆栈的信息
    6.在try中声明的变量，再出了try结构中，就不能够被调用了。        
    7.try-catch-finally结构也是可以嵌套的
                   
            体会：使用Try-catch-finally处理编译时异常，使得程序在编译时就不在报错，但是运行时仍可能报错
            相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现.
 *

关于：try-catch-finally中finally的使用
 * 1.finally是可选的
 * 2.finally中声明的是一定会被执行的代码，即使catch中又出现异常了，try中有return语句
 * 等情况。
 * 3.像数据库的连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，我们需要自己手动的进行资源
 * 的释放。此时的资源释放，就需要声明在finally中
 *
 *