Java基础学习笔记
面向对象
面向对象与面向过程
-
例子 ：我拿着课本学习
-
面向对象：我，课本，学习
-
面向过程：①我拿起课本，②开始学习
面向对象的三大特性
①封装性
-
高内聚，低耦合：类的内部自己完成，只放出少量的方法供外界调用
-
使用权限修饰符配合
-
设置私有的属性和方法，提供get、set方法进行调用
权限修饰符
-
四种权限修饰符都可以修饰类的内部结构：属性、方法、构造器、内部类
②继承性
子类 extends 父类
public Student extends Person{}
//子类继承父类后，就获得了父类中的属性和方法
//父类中private的属性和方法，仍然认为子类获取了，但是因为封装性的影响，不能直接调用
//子类继承后，可以声明自己特有的属性和方法
-
所有类都继承了Object类
-
类只有单继承，接口有多继承
方法重写
//override/overwrite 子类继承父类后对方法的重写
//子类重写方法的方法名和形参都要和父类被重写方法的方法名和形参一样
//子类重写方法的权限修饰符要 >= 父类被重写方法的权限修饰符
//子类不能重写父类中private的方法
//返回值类型：父类是void，子类只能是void
// 父类是A类型，子类可以是A类型或者A类型的子类
//子类抛出的异常类型 <= 父类抛出的异常类型
//static方法不可以被重写，不能被覆盖，是随着类的加载而加载的
super关键字
//子类有和父类同名的属性或者重写的方法，此时想使用父类中的，通过super.属性/方法进行调用
//构造器
③多态性
-
对象的多态性：父类的引用指向子类的对
-
编译看左边，运行看右边
-
只适用于方法，不适用于属性
//父类的引用指向子类的对象
Animal a = new Dog();
Dog b = new Dog();
//虽然指向子类，但不能调用子类特有的方法或属性
//只能调用父类中声明的方法。如果重写了父类的方法，就调用自己重写了的方法
//能执行哪种方法，主要看左边的类型
-
instanceof关键字
//可不可以调用子类特有的方法或属性呢？
//可以向下转型强转
Animal a = new Dog();
Dog b = (Dog)a;
//需要判断：a instanceof A --> 判断 (对象)a 是否是 (类)A 的实例。是，返回true，否，返回false
public class Main{
public static void main(String[] args){
Dog a = new Dog();
System.out.println(a instanceof Animal)；//true
}
}
class Animal{}
class Dog extends Animal{}
类
属性
public class student{
int num; //属性(成员变量) 直接定义在类内
// + 可以使用权限修饰符
// + 有默认初始化值
// + 加载到堆空间
//局部变量，定义在方法、方法形参、代码块、构造器、构造器形参、内的变量
// + 不可以使用权限修饰符
// + 没有默认初始化值
// + 加载到栈空间
}
//属性的初始化
关键字
//^this^
//可以用来修饰属性、方法、构造器 --> 可理解为当前对象
//this.属性/方法进行调用，通常情况下省略，类的属性和方法的形参同名时使用，此时调用的时类的属性
//调用构造器
public a(){}
public a(int a){
this();//调用上面的空构造器，同理可调用有参构造器;
this.a = a;
}
//^package^
//声明类或接口所属的包，写在首行
package com.java.www;
//^import^
//导入指定包下的类或接口
import java.util.*; //.*表示导入该包下的所有结构，如果是它的子包，仍需导入
//在java.lang包下定义的，默认导入了，可直接使用，不需要导入
//^static^
//可以用来修饰属性、方法、代码块、内部类
//随着类的加载而加载，由于类加载一次，静态变量只存在一份，先于对象的创建，存在方法区的静态域中
//通过类.静态变量名调用
//静态方法只能调用静态方法和静态属性 //}主要看生命周期
//非静态方法可以调用非静态和静态的方法和属性 //}
//在静态方法中不可以使用this、super关键字
//^final^ (类似const吧)
//可以用来修饰类、方法、变量
//修饰类，此类不能被继承
//修饰方法，此方法不能被重写
//修饰变量，此变量为常量 修饰属性时，只有定义初始化、代码块和构造器中初始化
//全局常量 static final
匿名对象
public class Main{
public static void main(String[] args){
//直接使用
new a().say();
}
}
public class a{
public void say(){
System.out.println("...");
}
}
方法
方法的重载
-
同类同名不同参的方法即为重载
-
与权限修饰符、返回类型、形参变量名、方法体都没有关系
public void add(int a, int b){}
public void add(long a, int b){}
public void add(int a, string b){}
可变参数
-
方法名(数据类型名... 变量名)
-
可以传入多个参数，不规定数量。
-
可以传入数组
-
只能放在参数列表的最后一个，且只能有一个可变参数
int[] arr = {1,2,3,4,5};
int ans1 = add(arr);
int ans2 = add(1,2,3,4,5,6);
public static int add(int... i){
int ret = 0;
//调用方法和数组一样
for(int j = 0; j < i.length; j++){
ret += i[j];
}
return ret;
}
构造器
-
作用：创建对象，给对象进行初始化
-
名字和类的名字一样，无返回类型
-
如果没有定义构造器，系统会默认提供一个空构造器(权限与类的权限一致)，自己定义了，系统不会提供空构造器
-
类中至少需要一个构造器
-
和方法一样可重载，无参构造，带参构造
public class Person{
String name = "";
public Person(){}
public Person(String name){
this.name = name;
}
}
包装类(封装类)
//基本数据类型 引用数据类型
byte --> Byte //}
short --> Short //}
int --> Integer //}
long --> Long //}都继承于Number类
float --> Float //}
double --> Double //}
boolean --> Boolean
char --> Character
-
基本数据类型、包装类、String类型之间的相互转换
//基本数据类型 -> 包装类 //}
Integer a = new Integer(11); //}
Integer a = new Integer("123"); //}
//} JDK 5.0 有自动装箱和自动拆箱，顾名思义可以直接 =
//包装类 -> 基本数据类型 //}
Integer a = new Integer(11); //}
int b = a.intValue(); //}
//基本数据类型、包装类 -> String
int a = 10;
String str1 = a + "";
String str2 = String.valueOf(a);
//基本数据类型、包装类 -> String
int a = Integer.parseInt("123"); (String)
代码块
-
作业：初始化类、对象
-
修饰符只有static可以用
//静态代码块 随着类加载而执行，只执行一次
static{}
//非静态代码块 随着对象的创建而执行，可以对对象的属性进行初始化
{}
抽象类
-
关键词 abstract
-
修饰类和方法
-
抽象类中可以 有/没有 普通方法，也可以 有/没有 抽象方法
-
但有抽象方法的类，一定要是抽象类
-
public abstract class Person{ //不能被实例化 --> ×Person a = new Person();
public abstract void work(); //只有方法声明，没得方法体
}
//要有构造器，构造器在子类中使用
//如果子类继承了抽象类，且抽象类中具有抽象方法，一定要重写抽象方法
public class Student extends Person{
public void work(){
System.out.println("走路");
}
}
//抽象类有什么用？
//一般在父类中方法没有什么方法体，就用抽象方法，就用抽象类。比如算面积，不知道是什么形状，面积公式不知道怎么写
内部类
-
A类声明在B类中，A类为内部类，B类为外部类
-
成员内部类（静态、非静态）和局部内部类（方法、代码块、构造器内）
-
①作为一个类，和普通类一样；
-
②作为外部类的成员，可以调用外部类的结构，可以被static修饰，可以被4种权限修饰符修饰
class Person{
int num;
static class Hand{
Person.this.num = 10; //调用外部类属性，一般来说，可以省略
}
class Leg{}
}
public class Main{
public static void main(String[] args){
//静态
Person.Hand a = new Person.Hand();
//非静态
Person b = new Person();
Person.Leg c = b.new Leg();
}
}
接口
-
关键词 interface(定义)、implements(继承)
-
接口中方法默认类型 public abstract，常量默认类型 public static final
-
接口不能定义构造器，不能被实例化
-
用类来实现接口，可以实现多个接口，多继承性
-
实现了接口，必须重写接口中的方法
public interface Time{
(public abstract) void tran(); //}默认是这个类型，可以省略
(public static final) int N = 110; //}
}
public Hit extends AA implements Time,BB,CC{
public void tran(){
System.out.println();
}
}
异常处理
-
关键词: try、catch、finally、throw、throws
-
方法中可主动抛出异常throw（方法中处理），方法上抛出异常throw（抛给别人处理）
-
①
try{ //try将可能出现异常的代码包装起来
//出现异常，会去匹配catch，匹配成功，跳出
语句1 //语句1出现异常后，语句2就不会执行了
语句2
}catch (异常类型 变量名){
//catch可以有多个，但是异常从小到大↓
//String getMessage() 获取异常信息
}catch (){
}finally{
//finally可有可无，无论有没有异常，最后一定都会执行
//即使try、catch中有return，也会执行
}
②
public static int divide(int a,int b) throws Exception{
if(b == 0){
throw new Exception(); //手动抛出异常
}else{
return a/b;
}
}
UML类图
浙公网安备 33010602011771号