- 属性+方法=类
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观 *** 作，仍然需要面向过程的思路去处理。
- 面向对象本质就是：以类的方式组织代码，以对象的组织（封装）数据。
- 从认识论角度考虑是先有对象后有类
- 三大特性：封装，继承，多态。
- main方法
//main方法
public static void main(String[] args){}
/*
修饰符 返回值类型 方法名(...){
//方法体
return 返回值;
}
*/
public String sayHello(){
return "hello world";
}
public void print(){
return;
}
public int max(int a,int b){
return a>b?a:b;
}
break：跳出switch循环，结束循环。continue：结束一次循环。return：方法结束，返回类型和返回值相同。
方法名：见名知意，驼峰命名法。参数列表：（参数类型，参数名），...可变参数，数组运用可变参数。
- 静态方法：
public static void say(){
system.out.print("1111");
}//可直接通过方法名调用，和类一起加载。
- 非静态方法
public void say(){
System.out.print("1111");
}
//调用
Student student = new Student();//实例化这个类new，对象类型 对象名=对象值;
student.say();
- 形参
public static int add(int a,int b){//int a,int b,形参
return a+b;
}
- 实参
public static void main(String[] args){
int add = Demo03.add(1,3);//1,3:实参
System.out.println(add);
}
- 值传递
//值传递
public class Demo04{
public static void main(String[] args){
int a = 1;
System.out.println(a); //1
Demo04.change(a);
System.out.println(a); // 1
}
//返回值为空
public static void change(int a){
a = 10;
}
}
a=10，返回值为空，a的值还为1。
- 引用传递
//引用传递：对象，本质还是值传递
public class Demo05{
public static void main(String[] args){
Person person = new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person,name);//test
}
public static void change(Person person){
//person是一个对象：指向的--->Person person=new Person();这是一个具体的人，可以改变属性
person.name = "test";
};
}
//定义了一个Person类，有一个属性：name
class Person{
String name;//null
}
- 基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的
- 对象作为参数传递时，是对象在内存中的地址拷贝一份给了参数
- 类是一种c的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- 对象是抽象概念的具体实例
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的使用
-
一个类即使什么都不写，它也会存在一个方法
-
构造器：
- 和类名相同
- 没有返回值
-
核心作用：
- 使用new关键字，本质是在调用构造器
- 构造器同来初始化值
-
在无参构造器中，无参构造器可以实例化初始值
- 注意点：
- 有参构造器：一旦定义了有参构造，无参就必须显示定义
- Alt+Insert
1.类与对象
类是一个模板：抽象，对象是一个具体的实例
2.方法
定义，通用
3.对应的引用
引用类型：基本类型（8）
对象是通过引用来 *** 作的：栈--->堆
4.属性：字段Field成员变量
默认初始化值如下：
数字：0 0.0
char：u0000
boolean：false
引用：null
修饰符 属性类型 属性名=属性值;
5.对象的创建和使用
必须使用new关键字创建对象，构造器Person xiaoming=new Perosn();
对象的属性 xiaoming.name
对象的方法 xiaoming.sleep()
6.类
静态的属性 属性
动态的行为 方法
5 封装- 该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
- 封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应该通过 *** 作接口来访问，称为信息隐藏。
- 属性私有，get/set
/*
1.提高代码的安全性，保护数据
2.隐藏代码的实现细节
3.统一结构
4.系统的可维护性
*/
//类 private:私有
public class Student {
//属性私有
private String name; //名字
private int id; //学号
private char sex; //性别
private int age;
//提供一些可以 *** 作这个属性的方法！
//提供一些public的get\set方法
//get 获得这个数据
public String getName(){
return this.name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
//学习（）
public void stduy(){
System.out.println("study");
}
//睡觉（）
public void sleep(){
System.out.println("sleep");
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<120 && age>=0 ) {
this.age = age;
}else{
this.age = 3;
}
}
}
//高内聚，低耦合Students s1=new Students();
s1.setAge(1200);
System.out.println(s1.getAge());
- 作用
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了
- 继承的本质是对某一批类的抽象，从而实现对世界更好的建模
- extends的意思是“扩展”。子类是父类的扩展，使用extends来表示
- Java中只有单继承，没有多继承！一个类只能继承一个父类
- 继承是类与类之间的一种关系，此外还有依赖、组合、聚合等
- 继承关系的两个类，一个是子类（派生类），一个是父类（基类）子类继承父类
- 子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承
- 在Java中，所有类，都默认直接或间接继承Object类（Ctrl+H可以查看类关系）
- 被final修饰的类，无法继承（断子绝孙）
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个（默认调用）
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
VS this
- 代表的对象不同：
- this：本身调用者这个对象
- super：代表父类对象的应用
- 前提
- this：没有继承也可以使用
- super：只能在继承条件下可以使用
- 构造方法
- this()：本类的构造
- super()：父类的构造
- super与this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用
super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行
- 重写：需要有继承关系，子类重写父类的方法！方法名必须相同
- 参数列表必须相同
- 修饰符可以扩大但是不可以缩小
- public>protected>default>private
- 抛出的异常：范围，可以被缩小，但是不能扩大：ClassNotFoundException-->Exception(大)
- 重写是方法的重写，与属性无关
- 重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
- 被static（属于类，不属于实例），final（常量方法），private（私有）修饰的方法不能重写
public class B{
public static void test(){静态方法
System.out.println("B==>test()")
}
}
public class A extends B{//继承
public static void test(){
System.out.println("A==>test()")
}
}
public class Application(){
public static void main(String[] args){
//方法的调用只和左边的定义的类型有关
A a = new A();
a.test();//打印A==>test()
//父类的引用指向了子类，但静态方法没有被重写
B b = new A();
b.test();//打印B==>test()
}
}
修改A.Java，B.java
public class B{
public void test(){//非静态方法
System.out.println("B==>test()");
}
}
public class A extends B{
@Override //重写了B的方法
public void test(){
System.out.println("A==>test()");
}
}
//父类的引用指向了子类
B b = new A();
//子类重写了父类的方法，执行子类的方法
b.test();//打印变成了A==>test()
/*
静态方法是类的方法，非静态方法是对象的方法。有static时，b调用了B类的方法，因为b是B类定义的。没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
*/
重写：子类的方法名必须和父类保持一致，方法体不同
被static(属于类，不属于实例)，final(常量方法)，private(私有)修饰的方法不能重写
为什么重写：
- 父类的功能，子类不一定需要，或者不一定满足
Alt + Insert ; override;
7 多态- 即同一方法可以根据发送对象的不同而采用不同的行为方式
- 一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
- 多态存在条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
注意点
- 多态是方法的多态，没有属性的多态
- 父类和子类，有联系 类型转换溢出：ClassCastException
- 存在条件：继承关系，方法需要重写，父类引用指向了子类对象
- instanceof引用类型比较，判断一个对象是什么类型
- 类型转换
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型，会丢失自己原来的一些方法
- 把父类转换为子类，向下转型，强制转换，才调用子类方法
- 方便方法的调用（转型），减少重复的代码，简洁
- 静态变量可以直接用类名访问，也称类变量
- 静态变量（或方法）对于类，所有对象（实例）共享
- 静态变量可以直接调用，但是非静态变量不可以直接调用
private static int age;
private double score;
public void run(){ }
public static void go(){ }
public static void main(String[] args){
Student s1 = new Student();
System.out.println(Student.age);
System.out.println(Student.score);
System.out.println(s1.ahe);
System.out.println(s1.score);
go();
run();
}
- 静态区代码加载类时一起被初始化，最早执行且只执行一次（第一次new）
public class Person{
{
System.out.println("匿名代码块");
}
static {
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args){
Person person = new Person();
System.out.println("=====================")
Person person2 = new Person();
System.out.println("=====================")
Person person3 = new Person();
}
}
- Math->随机数:
//静态导入包
import static java.lang.Math.random;
public class Application {
public static void main(String[] args) {
//第一种随机数，不用导包
System.out.println(Math.random());
//0.7562202902634543
//第二种随机数，静态导入包
System.out.println(random());
//0.5391606223844663
}
}
- abstract修饰的类就是抽象类，修饰的方法就是抽象方法
- 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类
- 抽象类不能使用new来创建对象，它是用来让子类继承的
- 抽象方法只有方法的声明，没有实现，让其子类实现
- 子类继承抽象类，必须实现抽象类的所有方法， 否则该子类也要声明为抽象类
- 编译器给抽象类添加了一个无参构造方法。
接口最能体现OOP的精髓，对 对象 的抽象
在Java编程语言中是一个抽象类型，是抽象对象的集合，对象通常以interface关键字来声明。
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）共存
- 接口：只有规范，无法自己实现
- 约束和实现分离->面向接口编程
接口就是规范，定义一组规则，它的本质是契约，制定好之后大家都要遵守。
声明
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
/**
*用户接口，需要实现类
*锻炼抽象的思维
*/
public interface UserService{
//定义的属性默认是静态常量：public static final
int age = 10;
//定义的方法是公共抽象：public abstract
void add(String str);
void delete(String str);
void update(String str);
void query(String str);
}
public interface TimeService{
void timer();
}
特性
- 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
- 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字
- 接口中的方法都是公有的。
实现
/*
抽象类用继承：extends
接口用实现：implements
类可以实现接口，需要实现所有方法！
利用接口实现伪多继承~
*/
public class UserServiceImplement implements UserService,TimeService{
@Override
public void add(String str){
}
@Override
public void delete(String str){
}
@Override
public void update(String str){
}
@Override
public void query(String str){
}
@Override
public void timer(){
}
}
类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常
在实现接口的时候，也要注意一些规则：
- 一个类只能继承一个类，但是能实现多个接口
- 一个接口能继承另一个接口，这和类之间的继承比较相似
继承
接口的继承使用extends关键字，子接口继承父类接口的方法
//文件名：Sports.java
public interface Sports{
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}
//文件名：Football.java
public interface Foorball extends Sports{
public void homeTeamScored(int points);
public void visitingTeamScored(int points)
public void endOfQuarter(int quarter);
}
//文件名：Hockey.java
public interface Hockey extends Sports{
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}
多继承
- 类不允许多继承
- 接口允许多继承
public interface Hockey extends Sports,Event
接口与类相似，一个接口可以有多个方法
接口与类的区别
- 接口不能被实例化
- 接口没有构造方法
- 接口中所有的方法必须是抽象方法
- 接口不能包含成员变量，除了static和final变量
- 接口不是被类继承，而是被类实现
- 接口支持多继承（实现类（implements） 可以实现多个接口）
- 实现类必须要重写接口中的方法
JDK8之后的新特性，支持在接口中实现具体方法，但需要default修饰。default修饰方法只能在接口中使用。
10 内部类内部类：在一个类的内部再定义一个类
class A{
class B{
}
}
A是B的外部类，B是A的内部类。
成员内部类
public class Outer{
private int id;
public void out(){
System.out.println("外部类的方法");
}
//成员内部类
public class Inner{
public void inner(){
System.out.println("内部类的方法");
}
//可以直接使用外部类的属性/方法
public void getOuterId(){
System.out.println("内部类调用外部类属性和方法");
//创建成员内部类之前肯定要创建外部类对象
//即使id不是静态变量，out不是静态方法，但创建外部类对象时已经存在。
System.out.pirntln(id);
out();
}
}
}
匿名内部类
public class Application{
public static void main(String[] args){
//匿名内部类在多线程中使用，到时候再深究
Thread thread = new Thread(new Runnable(){
@Override
public void run(){
System.out.println("匿名内部类实现线程的逻辑 *** 作");
}
});
//开启 *** 作
thread.start();
}
}
Java把溢出当做对象来处理，并定义了一个基类Java.lang.Throwable作为所有异常的超类。
Java语言定义了许多异常类在Java.lang标准包中，主要分为Error和Exception两大类。
五个关键字try、catch、finally、throw、throws
使用try和catch关键字可以捕获异常。try/catch代码块放在异常可能发生的地方。
try/catch代码块中的代码称为保护代码。
finally区可以不要，在IO流，资源关闭时使用。
捕获多个溢出：从小到大！
IDEA快捷键：选中健康区域代码-->Ctrl + Alt + T
public static void main(String[] args) {
int a=1;
int b=0;
try{
System.out.println(a/b);
}catch (Error e){
System.out.println("Error");
}catch(Exception e){
System.out.println("Exception");
}catch (Throwable t){
System.out.println("Throwable");
}finally {
System.out.println("finally");
}
}
public void a(){b();}
public void b(){a();}
抛出异常
throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型
throws是用在方法名尾部，可以声明抛出多个溢出，多个溢出之间用逗号隔开。
import java.io.*;
public class className{
public void withdraw(double amount) throws RemoteException,InsufficientFundsException{
//Method implementation
}
//Remainder of class definition
}
throw是用在方法体内，主动抛出异常
public class ThrowTest{
public static void main(String[] args){
int a = 1;
int b = 0;
try{
System.out.println(divide(a,b));
}catch (Exception e){
System.out.println("分母不能为0");
//e.printStackTrace();
}
}
public static double divide(int a,int b){
if(b == 0){
//主动抛出异常
throw new ArithmeticException();
}
return 1.0*a/b;
}
}
自定义异常
//自定义的异常类
public class MyException extends Exception{
private int detail;
public Myexception(int a){
this.detail = a;
}
//异常的处理信息
//tostring
@Override
public String toString(){
return "Myexception{" + "detail=" + detail + "}";
}
}
public class Appcication{
//可能存在异常方法
static void test(int a) throws MyException{
System.out.println("传递的参数为：" + a);
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("MyException=>" + e);
}
}
总结
- 处理运行是异常时，采用逻辑去合理规避，同时辅助try-catch处理
- 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
- 对于不确定的代码，也可以加上try-catch，处理潜在的异常
- 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
- 具体如何处理异常，要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）