封装

封装，就是隐藏实现细节，将属性私有化（private），提供公有方法访问私有属性，通过这些共有方法访问私有属性。

封装的实现

修改属性的可见性来限制对属性的访问

为每个属性创建一对赋值（setter）方法和取值（getter）方法，用于对这些属性的访问

在setter和getter方法中，加入对属性的存取限制

package CSDN; 
public class Teacher { 
    //1.使用private修饰符修饰属性，将属性的访问范围控制在本类中 
    private String name; 
    private int age; 
    //2.提供公共的setter和getter方法给其他的类调用 
    public void setName(String pname) { 
        name = pname; 
    }
    public void setAge(int page) { 
        if(page>=22) { 
            age = page; 
        }else { 
            System.out.println("教师最小年龄22岁"); 
            age = 22; 
        } 
    }
    public String getName() { 
        return name; 
    }
    public int getAge() { 
        return age; 
    }
    public String introduction() { 
        return "大家好，我是资深教师"+name+",今年"+age+"岁"; 
    } 
}

package CSDN; 
public class TestTeacher { 
    public static void main(String[] args) { 
        Teacher t = new Teacher(); 
        t.setName("张三"); 
        t.setAge(4); 
        System.out.println(t.getName()); 
        System.out.println(t.introduction()); 
    } 
} 

继承

·继承分为子类、父类；

·继承需要符合的关系：is-a，⽗类更通⽤、⼦类更具体 ；

·子类具有父类一般特性（包括属性和方法），以及自身特殊的特性；

·继承目的是减少重复代码的编写；

·关键词：extends 表示一个类继承了另一个类；

·子类的构造方法中，用关键词super可以调用父类的构造方法；

·父类中只定义一些通用的属性和方法；

·子类自动继承父类的属性和方法，子类只需要定义特定的属性和方法；

·方法重写后，通过super关键词调用父类的方法

#所有的Java类都直接或间接的继承了java.lang.Object类

//父类 
package CSDN; 
public class Teacher51 { 
    String name; // 姓名 
    String center; // 所属中心 
    //构造方法 
    public Teacher51(String name,String center) { 
        this.name = name; 
        this.center =center; 
    }
    // 授课方法 
    public void giveLesson() { 
        System.out.println("开始理论授课"); 
    }
    // 自我介绍 
    public void introduction() { 
        System.out.println("大家好，我是" + name + "所属中心是" + center); 
    } 
}

//子类 
package CSDN; 
//JAVA使用extends关键字表示继承 
public class JavaTeacher extends Teacher51 { 
    String hobby; //爱好 
    // 子类可以继承父类属性和方法，但是构造方法不能继承 
    // 如果父类自定义构造方法，子类也必须要自定义构造方法 
    // 子类构造方法的第一句必须使用super关键字调用父类的构造方法 
    // 构造方法 
    public JavaTeacher(String name, String center,String hobby) { 
        Super(name, center);// Teacher51(name,center) 
        this.hobby = hobby; 
    }
    // 重写 
    // 当子类继承的方法不好用，子类可以重写从父类继承的方法 
    // 方法名和参数要跟父类的方法保持一致 
    public void giveLesson() { 
        System.out.println("打开Eclipse");
        // 使用super关键字调用父类的方法 
        super.giveLesson(); 
    }
    public void play() { 
        System.out.println(name+"正在玩"+hobby); 
    } 
}

数组

概念

数组将值分类放，易于查找；

分类以存放不同类型的数据；

数组是一个变量，存储相同类型的一组数据；

数组中所有元素必须属于相同的数据类型；

数组的下标从0开始

使用方法

• 声明数组： 数据类型[]数组名：int[]a;

数据类型 数组名[]：int a[];

• 分配空间： a=new int[5];

数据类型[]数组名=new 数据类型[大小]：int[]a=new int[5];

• 赋值：a[0]=8;

 int[]a={1,2,3,4....};（只有声明时可以一次性赋值）；

int[]a=new int[]{1,2,3,4...};

• 处理数据：算数运算符：a[0]=a[0]*10;

a.length：数组a的长度，即数组a中数的个数；

#数组下表从0开始，所以数组中第一个数为a[0]，第二个为a[1]，以此类推。

#数组常和for循环搭配，例如求平均值，求和，最大值和最小值

数组的排序：

Arrays排序法

利用java中arrays自带排序方法：Arrays.sort(a)

输出Arrays排序：for(int i=0;i<a.length;i++){System.out.print(a[i]);}

冒泡算法排序

每一轮比较，都冒出一个数组中最大值的泡，若有n个数，则需要比较n-1轮，第i轮就需要比较n-1-i次。

冒泡排序思想：数组中的数两两⽐较，较⼤的数往右，⼩的数往左

package CSDN;
import java.util.Arrays;
public class java4 {
	public static void main(String[] args) {
		int[] a={53,123,1,5,351,5,898,985,356,788};
		for(int i=0;i<a.length;i++){						//数组名.length 返回数组的长度
			System.out.print(a[i]+",");
		}
		double avg;
		int sum=0;
		for(int i=0;i<a.length;i++){
			sum=sum+a[i];							//数组求和
		}
		System.out.println("\n数组和是："+sum);
		avg=(double)sum/a.length;						//数组求平均值
		System.out.println("数组平均值是："+avg);
		
		int max=a[0];
		for(int i=1;i<a.length;i++){
			if(a[i]>max){
				max=a[i];
			}
		}
		System.out.println("数组的最大值是："+max);		//数组求最大值
		int min=a[0];
		for(int i=1;i<a.length;i++){
			if(a[i]<min){
				min=a[i];
			}
		}
		System.out.println("数组的最小值是："+min);		//数组求最大值
		
		Arrays.sort(a);
		System.out.print("arrays自带排序：");			//Arrays类排序法
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
		for(int i=0;i<a.length-1;i++){						//冒泡算法排序
			for(int j=0;j<a.length-1-i;j++){
				if(a[j+1]<a[j]){
					int temp=a[j+1];
					a[j+1]=a[j];
					a[j]=temp;
				}
			}
		}
		System.out.print("\n冒泡算法排序：");		
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
	}
}

字符串

几种类型

计算字符串长度（返回类型int）：a.length();

字符串比较是否相等（返回类型boolean）：a.equals(b);

字符串连接（返回类型String）：a.concat(b);

取字符串中某一段（返回类型String）：

a.substring(b,c);（第一位数字符b下标从0开始，第二位数字符下标c从开始数为1）

例如a.substring(5,9);字符串a="我爱中华人民共和国"，a的下标从0开始数，即第一位字符为"我"，字符下标为0，所以字符下标为b=5的是字符"民"，c的下标从1开始数，即第一位字符为"我"，字符下标为1，所以字符下标为c=9的是字符"国"。故a.substring(5,9)代表的是字符串"民共和国"。

a.substring(5);（字符下标从0开始）

查找某个字符（串）在字符串中的位置（返回类型int）：

a.indexOf(“字符（串）”);（字符（串）第一次出现的位置）

a.lastindexOf(“字符（串）”);（字符（串）最后一次出现的位置）

public class java4 {
	public static void main(String[] args) {
	String s1="字符串";
	String s11="字符串";
	int s2=s1.length();
	String s3=s1.concat(s11);
	boolean s4=s1.equals(s3);
	int s5=s3.indexOf("字");
	int s6=s3.lastIndexOf("字");
	String s7=s3.substring(0);
	String s8=s3.substring(0, 3);
	System.out.println(s2);    //3
	System.out.println(s3);    //字符串字符串
	System.out.println(s4);    //false
	System.out.println(s5);    //0
	System.out.println(s6);    //3
	System.out.println(s7);    //字符串字符串
	System.out.println(s8);    //字符串
	}
}

异常

概念

程序在运行过程中所发生的不正常的事件，它会中断正在运行的程序

几种异常名称

Exception:异常的根类

ArithmeiticException：算数错误形式，如零作除数

ArrayIndexOutOfBoundsException：数组小于或大于实际的数组大小

InputMismatchException：数据类型与输入数据类型不匹配

IlegalArgumentException：方法接收到非法参数