7、包
创建包使用关键字
package （ package必须写在程序的第一行 ）
导入包使用关键字
import （只能引入其他包中的public类）
8、可见性修饰符
9、访问器方法
package object;
public class Car {
private String brand;
private String color;
private double speed;
public Car(String brand,String color) {
speed=0;
this.brand=brand;
this.color=color;
}
public String getBrand() {
return brand;
}
//获取属性方法：get属性名，没有参数，返回属性，返回值类型是属性类型
public String getColor() {
return color;
}
//设置属性的方法：set属性名，有形参，形参赋值给属性，没有返回值
public void setColor(String color) {
this.color = color;
}
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
this.speed = speed;
}
public static void main(String[] args) {
Car car=new Car("benz","black");
System.out.println(car.getBrand());
car.setSpeed(200);
System.out.println(car.getSpeed());
}
}
七、面向对象高级特性
1）继承
Java是
单重继承的
面向对象中在已有类的基础上扩展出新类的方式称为继承
父子类在一个包中，子类可以继承父类中的非私有属性和方法；父子类不在一个包中，子类可以继承 public 类中的public 属性和 protected 属性
属性看左边，方法看右边
package cn.tedu.design;
//1.通过归纳总结，使用关键字class抽象封装形成一个"类"组件来描述一类事物
class Car{
//2.属性--通过成员变量来描述
//2.1 属性的封装--通过关键字private对属性进行封装
private String brand;//品牌
private String color;//颜色
private double price;//价格
private double size;//尺寸
//3.行为--通过方法来描述
public void start(){
System.out.println("我的车车启动啦~");
}
public void stop(){
System.out.println("哎呀妈，我的车车熄火了~");
}
//2.2 给被封装的属性提供公共的属性值设置和访问方式--GetXxx()、SetXxx()
//快捷方式：右键->Generate->Getter and Setter->Shift全选->ok
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public double getSize() {
return size;
}
public void setSize(double size) {
this.size = size;
}
}
//4.创建一个宝马类并且继承汽车类--通过关键字extends建立继承关系
class BMW extends Car{
String color = "五彩斑斓的黑";
//6.子类对父类方法不满意时可以重写父类中的方法
//重写遵循两同两小一大原则，重写后，子类对象使用重写后的方法
@Override
public void stop(){
System.out.println("宝马当然要帅气的停的稳当些啦~");
}
}
//5.创建一个保时捷类并且继承汽车类--通过关键字extends建立继承关系
class BSJ extends Car{
String color = "黑不溜秋的白";
//7.新增子类特有功能--父类不可使用，只有子类对象可使用此功能
public void fly(){
System.out.println("启动加速度，我要起飞啦UP~UP~");
}
}
/*本类用于完成OOP汽车设计综合案例*/
public class DesignCar {
//创建程序的入口函数
public static void main(String[] args) {
//8.创建一个纯纯的父类对象进行测试
Car c = new Car();
System.out.println(c.getColor());//null,需要使用get()/默认值
c.start();//父类自己的功能
c.stop();//父类自己的功能
//c.fly();//父类不能使用子类的特有功能
//9.创建一个纯纯的子类宝马类对象
BMW b = new BMW();
System.out.println(b.color);//五彩斑斓的黑,子类新定义的同名属性
b.start();//没重写，使用的是父类的功能
b.stop();//重写了，使用的是自己重写以后的功能
//10.创建一个纯纯的子类保时捷类对象
BSJ b2 = new BSJ();
System.out.println(b2.getColor());//null
System.out.println(b2.color);//黑不溜秋的白
b2.start();//使用的是继承过来的父类中的功能
b2.fly();//使用的是子类特有的功能
}
}
继承中的构造方法：
可以通过这个关键字使用父类的内容,Super代表的是父类的一个引用对象
注意:在构造方法里,出现的调用位置必须是第一行
public class Person {
protected String id;
protected String name;
protected String birthday;
public Person(){}
public Person(String id,String name){
this.id=id;
this.name=name;
}
}
public class Teach extends Person{
public Teach(){
super();
}
public Teach(String id,String name){
super(id,name);
}
}
this与super的区别
2）多态
一种功能有多种实现。通过方法的重载和覆盖可以实现多态。
子类对象可以当作父类对象使用
父类对象不能当作子类对象使用
用
instanceof 操作符测试一个对象是否是一个类的实例
方法重载：
参数列表不同包括:参数数目不同,参数出现顺序不同,参数的类型不同.
静态绑定
方法覆盖（重写）：
子类与父类之间 方法头相同 方法体不同
动态绑定
final作用：
修饰类：不能被继承
修饰方法：不能被覆盖
修饰属性：不能重新赋值
修饰常量：不能重新赋值
3）抽象类
抽象类：用abstract修饰的类。
只能用于继承，不能用于创建对象
抽象方法：用abstract修饰的方法只有方法头没有方法体。
抽象方法只能定义在抽象类中
package cn.tedu.oop;
//1.创建父类Animal
/*2.被abstract修饰的类是抽象类
* 如果一个类中包含了抽象方法，那这个类必须被声明成一个抽象类*/
//4.2添加抽象方法后，本类需要用abstract修饰
abstract class Animal{
//3.创建普通方法
public void eat(){
System.out.println("吃啥都行~");
}
public void play(){
System.out.println("玩啥都行~");
}
//4.1创建抽象方法
/*1.被abstract修饰的方法是抽象方法，抽象方法没有方法体*/
public abstract void fly();
public abstract void fly2();
}
//2.创建子类Pig,并与Animal类建立继承关系
/*3.当一个子类继承了抽象父类以后，有两种解决方案：
* 方案一：变成抽象子类，“躺平，我也不实现，继续抽象”
* 方案二：实现抽象父类中的所有的抽象方法，“父债子偿”*/
//4.3子类需要处理，继续抽象/实现父类所有抽象方法
//abstract class Pig extends Animal{--方案一
class Pig extends Animal{//方案二
@Override//注解，标识这是一个重写的方法
public void fly() {
System.out.println("我爸的债我终于还清了，我家的猪终于飞起来了~");
}
@Override
public void fly2() {
System.out.println("抽象父类中的所有抽象方法都需要被实现");
}
}
/*本类用作抽象测试的入门案例*/
public class AbstractDemo {
public static void main(String[] args) {
/*4.抽象类不可以实例化！！！-创建对象*/
//5.测试抽象父类是否可以创建对象
//Animal a = new Animal();
//6.创建多态对象进行测试
Animal a = new Pig();
a.eat();//调用抽象父类的普通方法
a.fly();//调用抽象父类的抽象方法
}
}
4）接口
Java中的接口可以多重继承、接口只能继承接口，不能继承类
接口定义与类定义相似，但只能包含
静态常量和抽象方法。
一种用于描述类对外提供功能规范的、能够多重继承的、特殊的抽象类。
通过interface关键字来定义接口
通过implements让子类来实现接口
接口不能实例化，
但是接口对象可以指向它的实现类对象。
List Set Map都是接口使用时先实现List <String> list = new ArrayList <>（）;
接口的所有成员方法都具有（
public, abstract
）修饰的特性
1、 定义一个接口Eatable，其中定义void eat ()抽象方法，以描述可食用功能的规范；
2、定义抽象类水果Fruit，包含一个表示颜色的属性和一个打印属性基本信的方法；
package inter;
public interface IEatable {
void eat();
}
public abstract class Fruit {
String color;
public void show() {
System.out.println("color is "+color);
}
}
public class Apple extends Fruit implements IEatable{
@Override
public void eat() {
System.out.println("apple can be eaten");
}
public static void main(String[] args) {
}
}
八、异常处理
异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序
Java的异常处理是通过5个关键字来实现的：
try、catch、 finally、throws（用在方法声明处）、throw（用在方法内部）
异常处理只有两种方式: try-catch 和 throws,所以必须二选一
九、集合框架
Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于
java.util包中
Collection 接口存储一组
不唯一，无序的对象
List 接口存储一组
不唯一，有序（插入顺序）的对象
Set 接口存储一组
唯一，无序的对象
Collection保存单一元素，而Map保存相关联的键值对。
1）List接口实现类
ArrayList实现了
长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
LinkedList采用链表存储方式。插入、删除元素时效率比较高
List接口常用方法：
2）ArrayList集合类
package arraylist;
//编写一个用户管理类（UserManager），在类中定义一个Vector或ArrayList的成员变量，该变量保存所有的用户，用户对应的类型为User。在类中定义如下几个方法：
//添加一个用户。
//删除一个用户。
//判断一个用户是否存在。
//显示所有用户信（User对象有toString方法可以显示用户信）。
//User类：有个名字属性、有个toString方法，返回用户信
import java.util.*;
public class UserManager {
ArrayList<User> users=new ArrayList<>();//泛型：数据类型参数化——为了安全
public void addUser(User u) {
users.add(u);
}
public void removeUser(int i) {
users.remove(i);
}
public void removeUser(User i) {
users.remove(i);
}
// public void removeUser(String name) {
// for(int i=0;i<users.size();i++) {
// User u=(User)users.get(i);
// }
// }
public boolean isExistUser(User u) {
return users.contains(u);
}
// public void display (){
// for(int i=0;i<users.size();i++) {
// User u=(User)users.get(i);
// System.out.println(u);
// }
// }
public void display() {
Iterator<User> it=users.iterator();//获取集合users的迭代器it
while(it.hasNext()){
//hasnext方法是判断集合中是否有元素
User u=it.next();//next()获取集合中的元素
System.out.println(u);
}
// for(User u:users) {
// System.out.println(u);
// }
}
public static void main(String[] args) {
UserManager um=new UserManager();
User u1=new User("zhang1");
User u2=new User("zhang2");
User u3=new User("zhang3");
um.addUser(u1);
um.addUser(u2);
um.addUser(u3);
um.display();
um.removeUser(2);
System.out.println("------------------------------");
um.display();
um.removeUser(u1);
System.out.println("------------------------------");
um.display();
}
}
3）Map接口
package test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
/*本类用于测试Map接口*/
public class TestMap {
public static void main(String[] args) {
//1.创建Map对象
/*Map中的数据要符合映射规则,一定注意要同时指定 K 和 V 的数据类型
* 至于这个K和V要指定成什么类型的数据,取决于你的具体需求 */
Map<Integer,String> map = new HashMap<>();//注意导包:java.util
//2.常用方法测试
map.put(9527,"白骨精");//向集合中添加数据
map.put(9528,"黑熊精");
map.put(9528,"者行孙");
map.put(9529,"黄毛怪");
System.out.println(map);//查看集合中的元素
/*总结1:Map中存放的都是无序的数据
总结2 :Map中的key不可以重复,如果重复,此Key对应的Value会被覆盖
打印结果:{9527=白骨精, 9528=者行孙, 9529=黄毛怪},没有黑熊精*/
//3.测试常用方法
//map.clear();//清空集合
System.out.println(map.containsKey(9528));//true,查看是否包含指定的Key
System.out.println(map.containsValue("土地老儿"));//false,查看是否包含指定的Value
System.out.println(map.equals("者行孙"));//false,判断"者行孙"与map对象是否相等
System.out.println(map.get(9528));//者行孙,根据指定的Key来获取对应的Value
System.out.println(map.hashCode());//102939160,获取哈希码值
System.out.println(map.isEmpty());//false,判断集合是否为空
System.out.println(map.remove(9528));//删除指定的元素
System.out.println(map.get(9528));//null,说明映射关系已被移出
System.out.println(map.size());//2,获取集合中元素的个数
Collection<String> values = map.values();//把map集合中的所有Vlaue收集起来放到Collection中
System.out.println(values);//[白骨精, 黄毛怪]
}
}
4）遍历集合
