面向对象
1.什么是面向对象?
2.三大特性:
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类,是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
3.类和对象的关系
-
类是一种抽象的数据类型,它是对某一类事物整体描述定义,但是并不能代表某一个具体的事物.
动物、植物、手机、电…
-
Person类、Pet类、 Car类等, 这些类都是用来描述/定义某-类具体的事物应该具备的特点和行为
-
对象是抽象概念的具体实例
张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
-
能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念
4.创建和面向对象
先创一个学生类
public class Student {
//属性
String name ;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的,需要实例化
//类实例化之后会返回一个自己的对象!
//student对象就是一个Student类的具体实例！
Student student = new Student();
student.name = "小明";
student.age = 17;
System.out.println(student.name);
System.out.println(student.age);
}
构造器
1.构造器是什么？
1.1和类名相同
1.2没有返回值
2.作用:
2.1.使用new关键字,本质是在调用构造器
##### 2.2.用来初始化值
3.注意点:
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person() {
}
//有参构造:一旦定义了有参构造，无参构造必须显示定义
public Person(String name) {
this.name = name;
}
}
封装
1.该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
2.封装(数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
3.记住这句话就够了：属性私有，get/set
1.封装的好处:
2.实践
1.先创建一个学生类:
private:私有
public class Student {
//属性私有
private String name; //名字
private int id;//学号
private char sex;//性别
private int age;//年龄
提供一些可以操作这个属性的方法
提供一些public 的get、set方法
//get 获得这个数据
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
//set 给这个数据设置值
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120 || age<0){
System.out.println("输入年龄错误");
}else{
this.age = age;
}
}
2.创建一个实现类来测试
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.setName("番茄");//set 设置值
student.setAge(120);
System.out.println(student.getName()+"先生的年龄为"+student.getAge()+"岁");
继承
1.继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。**
2.extands的意思是“扩展”。子类是父类的扩展。
3.JAVA中类只有单继承，没有多继承!
4.被final修饰的类不能被继承。
5.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
6.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
7.子类和父类之间,从意义上讲应该具有"is a"的关系.
2.object类
3.super
注意点:
1.super调用 父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中!
3.super和 this 不能同时调用构造方法!
super和this的不同点:
1.代表的对象不同:
this 本身调用者这个对象
super:代表父类对象的应用
2.什么时候使用
this:没有继承也可以使用
super:只能在继承条件才可以使用
3.构造方法
this() : 本类的构造
super():父类的构造!
4.实践
在java中,所有的类,都默认直接或者间接继承object
私有的属性子类无法继承，除非有get/set方法
4.1.先创建一个Person类 人 ：父类
public class Person {
public Person() {
System.out.println("Person无参方法被执行了");
}
private int money = 10_0000_000;
protected String name ="fanqie";
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public void arr(){
System.out.println("说了一句话");
}
}
4.2.创建学生类 is 人 :派生类 子类
子类继承了父类,就会拥有父类的全部方法!
ublic class Student extends Person{
public Student() {
//隐藏代码:调用了父类的无参构造
super();//调用父类的构造器，必须要在子类构造器的第一行
System.out.println("Student无参方法被执行了");
}
private String name = "xiaoming";
public void arr(){
System.out.println("说了两句话");
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void test1(){
arr();
this.arr();
super.arr();
}
}
4.3.创建学生类 Teacher 老师 is 人 :派生类 子类
public class Teacher extends Person{
}
4.4.创建实现类测试一下
public class Application {
public static void main(String[] args) {
Student student = new Student(); //Person无参方法被执行了 Student无参方法被执行了
student.arr(); //说了两句话
System.out.println(student.getMoney()); //100000000
//super
System.out.println("=======================");
student.test("番茄");/*番茄
xiaoming
fanqie
*/
System.out.println("\n=======================");
student.test1();/*说了两句话
说了两句话
说了一句话
*/
}
}
方法的重写
1.重写:需要有继承关系，子类重写父类的方法!
-
方法名必须相同
-
参数列表列表必须相同
-
修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
-
抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
-
重写，子类的方法和父类必要一 致;方法体不同!
2.为什么需要重写？
父类的功能，子类不一定需要， 或者不一定满足!
3.快捷键
Alt +Insert ;---->override;
4.实践
重写多少方法的重写，和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
//Override重写
@Override//重写:有功能的注释!
public 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(); //A=>test()
}
}
多态
1.多态注意事项:
-
多态是方法的多态，属性没有多态
-
父类和子类，有联系 类型转换异常! ClassCastException!
-
存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
-
不能进行多态的方法：
-
instanceof：(类型转换)引用类型， 判断一个对象是什么类型
2.实践
2.1.创建一个父类
public class Person {
public void test(){
System.out.println("番茄永远滴神");
}
}
2.2.创建子类Student并继承Student
public class Student extends Person{
@Override //重写了父类的test方法
public void test() {
System.out.println("卢本伟永远滴神");
}
public void run(){
System.out.println("好好学习,天天向上");
}
}
2.3.创建Application实现类测试一下
public class Application {
public static void main(String[] args) {
//一个类的实际类型是确定的
//Student student = new Student()
//Person person = new Person()
//可以指向的引用类型就不确定了:父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的!
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
s1.test();
s2.test();//子类重写了父类的方法,执行子类的方法
s1.run();
((Student) s2).run();//子类重写了父类的方法。执行子类的方法
}
}
instanceof
instanceof：(类型转换)引用类型， 判断一个对象是什么类型
public class Person {
public void sun(){
System.out.println("番茄");
}
}
public class Student extends Person {
public void go(){
System.out.println("go");
}
}
public class Teacher extends Person{
}
System.out.println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系
public class Application {
public static void main(String[] args) {
//System.out.println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false
System.out.println(object instanceof Teacher);//false
System.out.println("==================================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
//System.out.println(person instanceof String);//编译报错!
System.out.println(person instanceof Teacher);//false
System.out.println("==================================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof String);//编译报错!
//System.out.println(student instanceof Teacher);//编译报错!
System.out.println("=================================");
//类型之间的转换:父 子
//高 低
Person person1 = new Student();
//student将这个对象转换为Student类型，我们就可以使用Student类型的方法了!
((Student) person1).go();
//子类转换为父类
Student student03 = new Student();
student03.go();
Person person01 = student;
}
}
总结:
Static
public class Person {
//2
{
System.out.println("匿名代码块");
}
//1 只执行一次
static {
System.out.println("静态代码块");
}
//3
public Person() {
System.out.println("构造器");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("======================");
Person person1 = new Person();
}
}
public class Student {
private static int age; //静态的变量 多线程！
private double score;//非静态的变量
private static void run(){
}
private void lu(){
run();//也可以直接调用静态方法
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);//可以直接类名.属性名
System.out.println(s1.score);
System.out.println(s1.age);
run();//可以直接调用
s1.lu();
}
}
静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());//随机产生随机数
System.out.println(random());//随机产生随机数 可以不用Math. 因为上面导入了静态导入包
System.out.println(PI);
}
}
抽象类
-
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方;如果修饰类，那么该类就是抽象类。
-
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
-
抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
-
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
-
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类
实践
abstract 抽象类:类 extends : 单继承~
public abstract class Action {
//约束有人帮我们实现~
//abstract， 抽象方法，只有方法名字，没有方法的实现!
public abstract void accp();
public void test(){
System.out.println("番茄");
}
//1. 不能new这个抽象类，只能靠子类去实现它;约束!
//2. 抽象类中可以写普通的方法~
//3. 抽象方法必须在抽象类中~
//抽象的抽象:约束~
//思考题? new，存在构造器么?
//存在的意义抽象出来~ 提高开发效率
}
抽象类的所有方法，继承了它的子类,都必须要实现它的方法，除非它的子类也是抽象类，那么将由子类的子类继承了后实现
public class Application extends Action {
@Override
public void accp() {
}
}
接口
实践
interface 定义接口的关键字,接口都需要有实现类
public interface Student {
//常量~ pubsic static final,一般不在接口中定义常量
int chengji = 99;
//按口中的所有定义的方法其实都是抽象的public abstract
void add(String name);
void delete(int age);
void select(double money);
void update(String gender);
}
public interface Person {
void PersonAdd(String PersonName);
}
//抽象类: extends
//类可以实现接口implements 按口
//实现了按口的类，就需要重写接口中的方法~
//多继承~利用接口实现多继承
public class StudentImpl implements Student,Person{
@Override
public void add(String name) {
}
@Override
public void delete(int age) {
}
@Override
public void select(double money) {
}
@Override
public void update(String gender) {
}
@Override
public void PersonAdd(String PersonName) {
}
}
总结：
-
约束
-
定义一些方法，让不同的人实现~ 10 —> 1
-
方法public abstract
-
常量public static final
-
接口不能被实例化，接口中没有构造方法
-
implements 可以实现多个接口
-
必须要重写接口中的方法
内部类
1.内部类是什么？
内部类就是在一个类的内部在定义一个类,比如，A类中定义一个B类,那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了
2.成员内部类
public class Outer {
private int a = 10;
public void out(){
System.out.println("这是外部类的方法");
}
public class test{
public void in(){
out();
System.out.println(a); //可以获得外部类的私有属性
System.out.println("这是内部类的方法");
}
}
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
outer.out();
//通过这个外部类来实例化内部类
Outer.test t = outer.new test();
t.in();
}
}
异常
什么是异常？
-
实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。
-
软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception,意思是例外。这些，例外情况，或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
-
异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等
-
异常发生在程序运行期间,它影响了正常的程序执行流程
-
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常:
-
检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了,这些异常在编译时不能被简单地忽略
-
运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略
-
错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时，一个错误就发生了，它们在编译也检查不到的
-
异常体系结构:
-
Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有是常的超类
-
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception
-
Error：
-
Exception：
-
Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的,当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程; Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
异常处理框架
public class Application { public static void main(String[] args) { try { new Application().test(1,0); } catch (ArithmeticException e) { e.printStackTrace(); } finally { } int a = 1; int b = 0; //假设要捕获多个异常,要从小到大！ try { //try 监控区域 System.out.println(a/b); }catch (Error error){ System.out.println("error程序出现异常"); } catch (Exception e) { //catch 捕获异常 //System.exit(0);手动停止 System.out.println("Exception程序出现异常"); e.printStackTrace();//打印错误的栈信息 }catch (Throwable t){ System.out.println("Throwable程序出现异常"); } finally { //处理善后工作 System.out.println("finally"); } //finally 可以不要finally 假设Io,资源,关闭！ } public void a(){b();}; public void b(){a();}; //假设这个方法中处理不了这个异常。在方法上抛出异常 public void test(int a,int b)throws ArithmeticException{ if (b==0) {//主动的抛出异常 throw throws,一般在方法中使用 throw new ArithmeticException(); } } }
-
-
自定义异常
1.使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可
2.在程序中使用自定义异常类，大体可分为以下几个步骤:
-
创建自定义异常类
-
在方法中通过throw关键字抛出异常对象
-
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
-
在出现异常方法的调用者中捕获并处理异常
//自定义的异常类
public class MyException extends Exception{
//传递数字>10
private int Detail;
public MyException(int detail) {
this.Detail = detail;
}
//toSting :异常的打印信息
@Override
public String toString() {
return "MyException{" +
"Detail=" + Detail +
'}';
}
}
public class Test02 {
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(9);
}catch (MyException e){
System.out.println("MyException=>"+e);
}
}
}
416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
