1.什么是面向对象?
2.面向过程与面向对象的区别
3.回顾方法的定义
- break和return的区别
跳出switch,结束循环和return的区别
- 方法名: 注意规范。驼峰命名法。
- 参数列表
- 异常抛出
4.回顾方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this 关键字
5.类与对象的创建
使用new关键字创建对象
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:
1、必须和类的名字相同
2、必须没有返回类型,也不能写void
package org.psmaxwell.oop.demo02;
//学生类
public class Student {
//属性: 字段
String name; //null
int age; //0
//方法
public void study(){
System.out.println(this.name +"在学习");
}
}
/**
* public static void main(String[] args) {
*
*
* // 类: 抽象的, 实例化
* // 类实例化后会返回一个自己的对象!
* //student 对象就是一个Student类的具体实例!
* Student xiaoming = new Student();
* Student xh = new Student();
*
* xiaoming.name = "小明";
* xiaoming.age = 3;
*
* System.out.println(xiaoming.name);
* System.out.println(xiaoming.age);
*
* xh.name = "小红";
* xh.age = 3;
*
* System.out.println(xh.name);
* System.out.println(xh.age);
*
* }
*/
6.构造器详解
package org.psmaxwell.oop.demo03;
public class Pet {
public String name;
public int age;
//无参构造
public void shout(){
System.out.println("叫了一声");
}
}
/**
*
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
*/
7.简单小结类与对象
1.类是一个模板,对象是一个具体的实例。
2.方法
定义、调用!
3.对应的引用
引用类型: 基本类型
对象是通过引用来操作的,栈---》堆
4.属性: 字段Field 成员变量
默认初始化
数字 : 0 0.0
char : u0000
boolean : false
引用 : null
修饰符 属性类型 属性名 = 属性值!
5.对象的创建和使用
- 必须使用new 关键字创造对象,构造器 Person Maxwell = new Person();
- 对象的属性 Maxwell.name
- 对象方法 Maxwell.sleep()
6.类
静态的属性 属性
动态的行为 方法
封装、继承、多态
8.封装详解
该露的露,该藏的藏
我们程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成。不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
封装(数据的隐藏)
通常,应禁止直接访问一个对象中数据的实际标识,而应通过操作接口来访问,这称为信息隐藏。
记住这句话就够了:属性私有,get/set
package org.psmaxwell.oop.Demo04;
//类 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;
}
// set 给这个数据设置值
public void setName(String name){
this.name=name;
}
//alt + Insert
public int getId() {
return id;
}
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) {
this.age = 3;
}else{
this.age = age;
}
}
}
/**
*
* Student s1 = new Student();
*
* s1.setName("Maxwell");
*
* System.out.println(s1.getName());
*
* s1.setAge(999); //不合法
*
* System.out.println(s1.getAge());
*/
9.什么是继承?
10.Super详解
super注意点:
1.调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中。
super和this不能同时调用构造方法。
Super Vs this:
代表的对象不同:
this : 本身调用者这个对象
super: 代表父类对象的应用
前提:
this : 没有继承也可以使用
super: 只能在继承条件下才可以使用
构造方法:
this() : 本类构造器。
super() : 父类构造器!
package org.psmaxwell.oop;
import org.psmaxwell.oop.demo05.Person;
import org.psmaxwell.oop.demo05.Student;
// 一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
Student student = new Student();
// student.test("小山");
// student.test1();
}
}
package org.psmaxwell.oop.demo05;
// 学生 is 人 子类 派生类
// 子类继承了父类,就会拥有父类的全部方法
public class Student extends Person {
public Student() {
//隐藏代码:调用了父类的无参构造
super();//调用父类的构造器,必须要在子类构造器的第一行。
System.out.println("Student无参构造执行了");
}
//Ctrl + H
private String name = "xiaoshan";
public void print(){
System.out.println("Student");
}
public void test1(){
print(); //Student
this.print(); //Student
super.print(); //Person
}
public void test2(String name){
System.out.println(name); // 小山 main
System.out.println(this.name); //调用子类
System.out.println(super.name); //调用父类
}
}
package org.psmaxwell.oop.demo05;
//Person is 人 父类
//在Java中,所有的类,都默认直接或者间接继承Object
public class Person /*extends Object*/{
public Person() {
System.out.println("Person无参执行了");
}
protected String name = "Maxwell";
//私有的东西无法被继承
public void print(){
System.out.println("Person");
}
}
11.方法重写
---重写
重写: 需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可以扩大; public> protected>Default>private
4.抛出的异常:范围可以被缩小,但不能扩大;ClassNotFoundException ---> Exception(大)
重写,子类的方法和父类必须一致;方法体不同
为什么需要重写?
1.父类的功能,子类不一定需要,或者不一定满足。
Alt + Insert :overwrite;
package org.psmaxwell.oop;
import org.psmaxwell.oop.demo05.A;
import org.psmaxwell.oop.demo05.B;
//静态的方法和非静态方法区别很大!
//非静态: 重写
public class Application {
public static void main(String[] args) {
// 静态方法: //方法的调用只和左边,定义的数据类型有关
A a = new A();
a.test(); //A
//父类的引用指向子类
B b = new A(); //子类重写了父类的方法
b.test(); //B
}
}
package org.psmaxwell.oop.demo05;
//继承
public class A extends B{
//重写
@java.lang.Override //注解
public void test() {
System.out.println("A=>test()");
}
}
package org.psmaxwell.oop.demo05;
//重写都是方法的重写,与属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
12.instanceof和类型转换
package org.psmaxwell.oop;
import org.psmaxwell.oop.demo06.Person;
import org.psmaxwell.oop.demo06.Student;
import org.psmaxwell.oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
//类型之间的转换 父 子
//高 低
Person obj = new Student();
//student 将这个对象转换为Student类型,我们就可以使用Student类型的方法了。
// 子类转父类可能丢失自己的本来的一些方法!
// Student student = (Student) obj;
// student.go();
((Student) obj).go();
/**
* 1.父类的引用执行子类的对象
* 2.把子类转换为父类,向上转型
* 3.把父类转换为子类,向下转型,强制转换。
* 4.方便方法的调用,减少重复的代码,简洁
*
* 封装、继承、多态、接口
* 多实践、多测试、实践出真知。
*
*
*/
}
}
package org.psmaxwell.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package org.psmaxwell.oop.demo06;
public class Student extends Person {
public void go(){
System.out.println("go");
}
}
/**
*
* public class Student extends Person {
*
* @java.lang.Override
* public void run() {
* System.out.println("son");
* }
*
* public void eat(){
* System.out.println("eating");
* }
* }
*
*
*
*/
/**
*
* // Object > String
* // Object > Person > Teacher
* // Object > Person > Student
* Object object = new Student();
*
* //System.out.println(x instanceof y); //能不能通过
*
* 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 Teacher); //false
* System.out.println(object instanceof String); //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 Teacher); //false
* // System.out.println(person instanceof String); //编译报错
*
*
* 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 Teacher); //编译报错
* //System.out.println(student instanceof String); //编译报错
*/
13.static关键字详解
package org.psmaxwell.oop.demo07;
//静态导入包
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(PI);
}
}
package org.psmaxwell.oop;
public class Application {
public static void main(String[] args) {
}
}
package org.psmaxwell.oop.demo07;
//static
public class Student {
private static int age; //静态的变量
private double score; //非静态变量
public void run(){
go();
}
public static void go(){
}
public static void main(String[] args) {
Student.go();
}
}
package org.psmaxwell.oop.demo07;
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 person2 = new Person();
}
}
14.抽象类
- abstract 修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法,如果修饰类,那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
- 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
- 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
- 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
package org.psmaxwell.oop.demo08;
//abstract 抽象类 类 extends: 单继承 (接口可以多继承)
public abstract class Action {
// 约束 有人帮我们实现-
// abstract ,抽象方法,只有方法名字,没有方法的实现。
//约束- 有人帮我们实现 抽象方法,只有方法的名字,没有方法的实现
public abstract void doSomething();
//1.不能new这个抽象类, 只能靠子类去实现它,约束。
//2.抽象类中可以写普通的方法
//3.抽象方法必须在抽象类中
//抽象的抽象 : 约束
// 思考题 new , 存在构造器吗?
//存在的意义 抽象出来, 提高开发效率
}
package org.psmaxwell.oop.demo08;
//抽象类的所有方法,都继承了它的子类,都必须要实现它的方法 除非
public class A extends Action{
@java.lang.Override
public void doSomething() {
}
}
15.接口的定义与实现
package org.psmaxwell.oop.demo09;
//抽象的思维 Java
//interface 定义的关键字, 接口都需要有实现类。
public interface UserService {
//常量
public static final int AGE = 99;
//接口中的所有定义其实都是抽象的public
void run(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package org.psmaxwell.oop.demo09;
//抽象类 : extends
// 类 可以实现接口 implements 接口
// 实现了接口的类, 就需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@java.lang.Override
public void run(java.lang.String name) {
}
@java.lang.Override
public void delete(java.lang.String name) {
}
@java.lang.Override
public void update(java.lang.String name) {
}
@java.lang.Override
public void query(java.lang.String name) {
}
@java.lang.Override
public void timer() {
}
}
package org.psmaxwell.oop.demo09;
public interface TimeService {
void timer();
}
作用:
1.约束
2.定义一些方法,让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例化,接口中没有构造方法
6.implements 可以实现多个接口
7.必须要重写接口中的方法
8.总结博客
16.N种内部类
package org.psmaxwell.oop.demo10;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
package org.psmaxwell.oop;
import org.psmaxwell.oop.demo10.Outer;
public class Application {
public static void main(String[] args) {
// new
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}
package org.psmaxwell.oop.demo10;
public class Outer {
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类,但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
package org.psmaxwell.oop.demo10;
public class Outer {
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类,但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
package org.psmaxwell.oop.demo10;
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用讲实例保存到变量
new Apple().eat();
UserService userService = new UserService(){
@java.lang.Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}