JavaSE笔记04
JavaSE笔记04
一：面向对象
- java的核心思想就是：oop
- 面向对象的本质是：以类的方式组织代码，以对象的组织（封装）数据
- 三大特性：封装、继承、多态
- 先有类，后有对象。类是对象的模版
类和对象
package day02;
public class Student {
// 属性
String name;
int age;
// 方法
public void study(){
System.out.println(name+"在学习");
}
}
package day02;
public class Demo06 {
public static void main(String[] args) {
// 类实力化后会返回一个自己的对象
Student xiaoming = new Student();
xiaoming.name = "xiaoming";
xiaoming.age=3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
Student xiaohong = new Student();
xiaohong.name = "小红";
xiaohong.age = 4;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
}
}
构造器
- 默认类中有构造器（构造方法），无参数的
- 可以自己写带有参数构造方法，无参数的构造方法如果写可以用，不写不可以用（方法重载）
- 无参数的构造方法一般是用来设置默认值的
package day02;
public class Student {
// 属性
String name;
int age;
// 构造方法（构造器）
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 方法
public void study(){
System.out.println(name+"在学习");
}
}
package day02;
public class Student {
// 属性
String name;
int age;
public Student() {
}
// 构造方法（构造器）
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 方法
public void study(){
System.out.println(name+"在学习");
}
}
package day02;
public class Demo06 {
public static void main(String[] args) {
// 类实力化后会返回一个自己的对象
Student xiaoming = new Student();
xiaoming.name = "小明";
xiaoming.age=3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
Student xiaohong = new Student();
xiaohong.name = "小红";
xiaohong.age = 4;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
Student daming = new Student("大民", 4);
System.out.println(daming.name);
System.out.println(daming.age);
}
}
二：封装
基本情况
- 数据的隐藏
- 禁止直接访问一个对象中的数据的实际表示，而应该通过操作接口来访问
- 属性私有，get/set
- 提高程序安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性提高
package day02;
public class Person {
private String name;
private int age;
public void study(){
System.out.println("学习");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package day02;
public class Demo07 {
public static void main(String[] args) {
Person person = new Person();
person.setName("小明");
person.setAge(20);
System.out.println(person.getName());
System.out.println(person.getAge());
}
}
三：继承
基本情况
- 某一批类的抽象，实现对现实世界更好的建模
- extends，子类是父类的扩展
- java中只有单继承，没有多继承
- 继承是类与类中的关系，类与类之间还有：依赖、组合、聚合
- 继承关系的两个类，一个是子类（派生类），一个是父类（基类）
- 子类继承父类，拥有父类的全部方法
- 如果父类中方法、属性修改的为private，子类不能使用
- 所有的类都默认继承Object
package day02;
public class Teacher extends Person {
}
super
- Super为父类，super.属性、super.方法
- 子类构造方法自动隐藏super(),会先调用父类构造器，然后调用自己
- 只能出现在子类的方法和构造器中
this
- 本身调用者这个对象
- 没有继承也可以用
package day02;
public class Person {
protected String name = "小明";
public void print(){
System.out.println("Person");
}
}
package day02;
public class Student extends Person{
private String name = "小红";
public void test(String name){
System.out.println(name);
// this为本对象
System.out.println(this.name);
// super为父类
System.out.println(super.name);
}
public void print(){
System.out.println("Student");
}
public void test1(){
print();
this.print();
super.print();
}
}
package day02;
public class Demo08 {
public static void main(String[] args) {
Student student = new Student();
student.test("哈哈哈");
student.test1();
}
}
方法重写
public > protected > default > private
子类继承父类方法后，不适用、不需要、不满足，需要自己写
- 方法重写：不能添加static，添加以后就不会有效果
- 方法修饰只能是一定要扩大，父类的修饰符>子类的修饰符；抛出的异常：范围，可以缩小，不能扩大
- 只有子类继承父类才有方法的重写，方法都一样，方法名字一样，方法参数相同
package day02;
public class B {
public void test(){
System.out.println("B===>test");
}
}
package day02;
public class A extends B{
@Override
public void test(){
System.out.println("A===>test");
}
}
package day02;
public class Demo09 {
public static void main(String[] args) {
A a = new A();
a.test();
B b = new A();
b.test();
}
}
四：多态
基本情况
- 多态是方法的多态，属性没有多态
- instanceof：判断一个对象为甚么类型
- 多态存在的条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
package day02;
public class Person {
public void run(){
}
}
package day02;
public class Student extends Person{
}
package day02;
public class Demo10 {
public static void main(String[] args) {
// 一个对象的实际类型是确定的
// 可以指向的引用类型就不确定了
Student student = new Student();
Person person = new Student();
Object object = new Student();
person.run();
// 子类可以调用父类中的方法
student.run();
// 父类不能调用子类独有的方法
// object.run();
}
}
强制类型转换
- instanceof：有继承才能判断，有关系返回True
- 强制类型转换：Student stu = (student)person;
- 子类强制转换成父类，就丢失自己独有的方法
package day02;
public class Demo11 {
public static void main(String[] args) {
Student student = new Student();
Person person = new Student();
Object object = new Student();
System.out.println(student instanceof Person); //True
System.out.println(person instanceof Student); //True
System.out.println(object instanceof String); //false
Student stu = (student)person;
stu.run();
}
}
五：static
- 可以修饰属性、方法
- 修饰属性的时候，属性可以让类直接使用，对象也可以使用
- 修饰方法，该方法可以让类直接调用，对象可以调用
- 修饰的方法和属性，当类加载的时候就完成了创建，可以使用了，非静态的只有创建对象的时候才创建
- 匿名代码块、静态代码块、构造器。静态代码块 > 匿名代码块 > 构造器。静态代码块只会执行一次
package day03;
import day02.Person;
public class Demo01 {
{
System.out.println("匿名代码块");
}
static {
System.out.println("静态代码块");
}
public Demo01() {
System.out.println("构造器");
}
public static void main(String[] args) {
Demo01 demo01 = new Demo01();
}
}
静态代码块
匿名代码块
构造器
六：抽象类
- abstract修饰
- abstract可以修改方法，也可以抽象修饰类；抽象方法只能出现在抽象类中
- 抽象类不能通过new创建对象，抽象类专门用来让子类继承的
- 抽象方法，只有方法的声明，没有具体的方法实现，它是用来让子类实现的
- 子类继承抽象类，就必须实现抽象类没有实现的方法，否则该子类也要声明为抽象类
package day03;
public abstract class Demo02 {
public abstract void run();
public abstract int study();
}
package day03;
public class Demo03 extends Demo02 {
@Override
public void run() {
}
@Override
public int study() {
return 0;
}
}
七：接口
- 只有普通的规范，定义的是一组规则
- interface
- 一个类要实现一个接口，就要实现这个接口中所有的方法
- 一个类可以实现多个接口，但是只能继承一个类
- 可以定义变量,默认就是常量；接口可以通过new创建对象
package day03;
public interface Demo04 {
// 接口中所有的定义都是抽象的。默认的
public void run();
void study();
}
package day03;
public class Demo05 implements Demo04{
@Override
public void run() {
}
@Override
public void study() {
}
}
package day03;
public interface Demo06 {
void getID();
}
package day03;
public class Demo05 implements Demo04,Demo06{
@Override
public void run() {
}
@Override
public void study() {
}
@Override
public void getID() {
}
}
八：内部类
- 一个java文件中只能有一个public修改的类，可以有多个class类
- 方法中也可以写类：局部内部类
- 没有名字的类：匿名内部类
异常机制
基本情况
- java把异常当作对象处理，并定义了一个基类java.lang.Throwable作为所有异常的超类
- 在javaAPI 已经定义了许多异常类，分为两大类：Error、Exception
- 关键字：try、catch、finally、throw、throws
- finally：可以有，也可以没有
- catch中小的异常写上面，大的异常写下面
- 方法才能跑出异常：这个方法出现异常，处理不了；方法中用：throw；方法上用：throws
- try--catch添加后，有问题后程序可以继续执行
package day03;
public class Demo08 {
public static void main(String[] args) {
int a = 1;
int b = 0;
try {
System.out.println(a/b);
}catch (ArithmeticException e) {
System.out.println("变量b不能为0");
}catch（Throwable e）P{
system.out.println("大的异常")
}finally {
System.out.println("finally");
}
}
}
public void add() throws ArithmeticException{
if( b == 0){
//主动跑出异常
throw new ArithmeticException();
}
}
自定义异常
- 用户自定义异常类，只需要继承Excetion类即可
package day03;
public class MyException extends Exception {
// 数字大于10
private int detail;
public MyException(int a) {
this.detail = a;
}
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
package day03;
public class Demo09 {
// 可能会存在异常的方法
static void test(int a) throws MyException{
if (a > 10){
throw new MyException(a);
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
System.out.println(e);
}
}
}
浙公网安备 33010602011771号