1.private 修饰符 *
1.1为什么要实现封装
其目的是将对象中的属性和方法组织起来。同时隐藏不想暴露的属性和方法及实现细节。
1.2 怎么实现封装
第一步：属性私有化（使用private关键字将类中的属性进行修饰。）
第二步：如果外界想要访问私有属性，就需要提供get、set方法，外部程序只能通过set方法修改，只能通过get方法读。(提供get、set方法)
1.3 封装与不封装的区别
属性封装之前，外界可以随意的访问修改。
属性封装之后，外界只可以通过get、set方法访问修改
public class dog {
//不封装属性
int age;
String name;
//封装属性
private int age;
private String name;
//提供get、set方法供外界使用
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class demo {
public static void main(String[] args) {
//实列化,要想使用类中的属性，需要实列化才可以调用
dog dog = new dog();
//属性不封装，外界可以随意赋值
System.out.println(dog.age = 10); //输出10
//属性封装,外界不可以赋值，需要通过set方法赋值，get方法读取
System.out.println(dog.age = 10); //报错
//使用set方法赋值
dogs.setAge(10);
//使用get方法读取
System.out.println(dogs.getAge()); //输出10
}
}
2.this关键字
2.1 通过this关键字调用成员变量
public class thiss {
int age;
public thiss(int age) { //有参构造方法，没有返回值，名字和类名一样
this.age = age; //将局部变量age的值赋值给成员变量
}
public static void main(String[] args) {
thiss t = new thiss(999); //给有参构造方法传值
System.out.println(t.age); //输出999
}
}2.2 通过this关键字调用成员方法
public class thiss {
public void name() {
System.out.print("我是傅");
}
public void age() {
//调用name方法
this.name();
System.out.println("，我今年19岁");
}
public static void main(String[] args) {
//要想使用类中的属性，需要实列化
thiss thiss = new thiss();
thiss.age(); //输出我是傅，我今年19岁
}
}2.3 通过this关键字调用构造方法
public class thiss {
public thiss() {
System.out.print("我是无参构造方法，");
}
public thiss(int age) {
this(); //调用无参构造方法
System.out.println("我是有参构造方法");
}
public static void main(String[] args) {
//要想使用类中的属性，需要实列化
thiss thiss = new thiss(19);
System.out.println(thiss); //输出我是无参构造方法，我是有参构造方法，task1.thiss@b4c966a
}
}
3.类的继承
3.1 什么是继承
继承是指在一个现有的类的基础上去创建一个新的类，创建出来的新类被称为子类，现有类被称为父类，子类会自动继承父类所有可以继承的属性和方法。
3.2 语法及示例
[修饰符] class 子类名 extends 父类名 {
//程序核心代码
}public class Animal{
String name;
void show() {
System.out.println("叫!");
}
}
public class Dog extends Animal{
public static void main(String[] args) {
Dog dog = new Dog();
dog.name = "狗";
System.out.print(dog.name);
dog.show(); //输出狗叫！
}
}
3.3 方法重写
字类会自动继承父类中公共的方法，但有时在子类中需要对继承的方法进行一些修改，即对类的方法进行重写。需要注意的是（类中重写的方法需要和父类重写的方法具有相同的方法名、参数列表以及返回值类型）
public class Animal{
String name;
//定义动物叫的方法
void show() {
System.out.println("叫!");
}
}
//继承分类Animal的属性
public class Dog extends Animal{
//在eclipse中： alt+shift+s选择Override ...进行方法重写
@Override //@Override 强制检查方法是否是重写的方法
//定义狗叫的方法
void show() {
System.out.println("狗叫");
}
int age;
//为什么要写main方法，有main方法才可以测试输出
public static void main(String[] args) {
//可以怎么讲，想要使用main方法外面的属性，就要实例化
Dog dog = new Dog();
dog.show(); //输出狗叫
}
}
3.4 super关键字
子类对象重写父类方法后，子类对象将无法直接访问父类被重写的方法，为了解决这个问题，在java中专门提供了一个supper关键字来访问父类的成员变量、成员方法、构造方法。
注意: 不可以在静态上下文中使用super,
3.41 语法
supper.成员表量
supper.成员方法([参数一，参数二...])
注意:
1.Super()只能用在子类的构造方法中使用，在其它地方使用存在编译错误。
2.super（）构造的父类只有在子类中有效，离开子类无法使用。
3.super.的调用的是由在子类构造的时候使用了super()的无参或者有参构造出来的父类。
4.当父类为有参构造而不写无参构造的时候，我们子类构造方法必须拥有父类的构造方法就需要用Super(String xx,int no)的构造方法将把父类构造出来才能继续构造子类。
5.当存在子类没有重写父类的方法时候，此时使用this.与super. 的结果相同3.42 示例
public class Animal{
String name = "动物";
//定义动物叫的方法
void show() {
System.out.println("叫!");
}
//求和
void add(int a,int b) {
System.out.println(a+"+"+b+"="+(a+b));
}
}
public class Dog extends Animal{
//在eclipse中： alt+shift+s选择Override ...进行方法重写
@Override //@Override 强制检查方法是否是重写的方法
//重写父类的方法
void show() {
super.show(); //访问父类的成员方法
}
@Override
void add(int a, int b) {
super.add(a, b); //访问父类有参成员方法
}
//定义打印name的方法
void printName() {
System.out.println("name="+super.name); 访问父类的成员变量
}
//为什么要写main方法，有main方法才可以测试输出
public static void main(String[] args) {
//可以怎么讲，想要使用main方法外面的属性，就要实例化
Dog dog = new Dog();
dog.show(); //叫!
dog.add(13,14 ); //13+14=27
dog.printName(); //name=动物
}
}4.接口 *
4.1 什么是接口
接口是一种标准，可以用于内部模块对模块、外部系统对其他服务提供的可调用或连接的能力的标准1。在Java语言中，接口是一种类型，是方法的集合，包含抽象方法、默认方法和静态方法，是对功能的扩展，也是声明规则的一种方式2。它是数据传递的通道，也是后台的一个函数，接口文档里面描述的接口参数其实就是函数的参数，接口的返回数据就是函数的返回值
4.2 注意
1. 定义接口使用interface关键字
2. 接口的方法默认都是public abstract的,可以省略
3 .接口中的变量默认都是public static final类型的，所以必须显示的初始化
4.定义默认方法和静态方法时，可以有方法体
5.接口的实现类必须实现接口中的所有抽象方法
6.接口的实例化对象可以访问接口中的常量、接口实现方法、以及默认方法，静态方法(类方法)可以直接使用接口名调用；
7.接口和接口可以有继承关系
4.3 语法
[修饰符] interface 接口名 [extends 父接口1,父接口2...] {
[public] [static] [final] 常量类型 常量名 = 常量值;
[public] [abstract] 方法返回值类型 方法名（[参数列表1]）;
[public] [default] 方法返回值类型 方法名（[参数列表1]{
//默认方法的方法体
};
[public] [static] 方法返回值类型 方法名（[参数列表1]{
//类方法的方法体
};
}
4.4 示例
public interface Animal {
//定义全局变量
int ID = 1; //默认是public static final修饰
//定义抽象方法
void breathe(); //默认是public abstract修饰
//定义一个默认方法
default void getType(String type) {
System.out.println("该动物属于: "+type);
}
//定义一个静态方法
static int getID() {
return Animal.ID;
}
}
//实现Animal接口
public class Dog implements Animal{
//实现接口中的抽象方法
@Override
public void breathe() {
// TODO Auto-generated method stub
System.out.println("狗在呼吸!");
}
public static void main(String[] args) {
//通过接口名调用类方法
System.out.println(Animal.getID());
//实例化Dog
Dog dog = new Dog();
//获取接口全局变量
System.out.println(dog.ID);
//调用breath方法
dog.breathe();
//调用getType方法
dog.getType("犬科");
}
}
5.异常
5.1 异常的类型
编译时异常：编译时异常的特点是在程序编写过程中，Java编译器就会对编写的代码进行检查，如果出现比较明显的异常就必须对异常进行处理，否则程序无法通过编译。
处理编译时异常有两种方式，具体如下：
·使用try……catch语句对异常进行捕获处理。
·使用throws关键字声明抛出异常，让调用者对其处理。运行时异常: 运行时异常是在程序运行时由Java虚拟机自动进行捕获处理的，即使没有使用try…catch语句捕获或使用throws关键字声明抛出，程序也能编译通过，只是在运行过程中可能报错.
| 异常类名称 | 异常类说明 |
| ArithmeticException | 算术异常 |
| IndexOutOfBoundsException | 角标越界异常 |
| ClassCastException | 类型转换异常 |
| NullPointerException | 空指针异常 |
| NumberFormatException | 数字格式化异常 |
5.2 语法
public class add {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
//可能发生异常的语句
int[] arr = {1,2,3};
System.out.println(arr[3]); //角标越界异常
} catch (Exception e) {
//对捕获的异常进行处理
e.printStackTrace(); //追踪输出标准错误流
}finally {
//执行finally语句块，无论程序是否异常，都会执行
}
}
}