Java核心思想面向对象编程
初始面向对象
方法回顾和加深
package oop.Demo01;
import java.io.IOException;
//Demo 01 类
public class Demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名(。。。){
//方法体
return 返回值;
}
*/
//return 结束方法,返回一个结果!
public String sayHello(){
return "heelo,world";
}
public int max(int a,int b){
return a>b ? a : b;//三元运算符
}
//数组下标越界
public void readFile(String file) throws IOException{
}
}
package oop.Demo01;
public class Demo02 {
public static void main(String[] args) {
//实列化这个类 new
//对象类型 对象名 = 对象值;
Student student = new Student();
student.say();
}
// 和类一起加载的
public void a(){
b();
}
//类实例化 之后才存在
public void b(){
}
}
package oop.Demo01;
//学生类
public class Student {
//静态方法
public static void say(){
System.out.println("学生说话了");
}
}
package oop.Demo01;
public class Demo03 {
public static void main(String[] args) {
//实际参数 实际参数和形式参数的类型要对应
int add = Demo03.add(1,2);
System.out.println(add);
}
//形式参数
public static int add(int a,int b){
return a+b;
}
}
package oop.Demo01;
//值传递
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;
}
}
package oop.Demo01;
//引用传递:对象,本质还是值传递
//对象,内存不理解 有点晕
public class Demoo05 {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name);//null
Demoo05.change(perosn);
System.out.println(perosn.name);//宋超
}
public static void change(Perosn perosn){
//perosn是一个对象:指向的 --->Perosn perosn = new Perosn();这是一个具体的人,可以改变属性!
perosn.name = "宋超";
}
}
//定义了一个perosn类,有一个属性;name
class Perosn{
String name;//默认值 null
}
对象的创建分析
package oop.Demo02;
//学生类
public class Student {
//属性:字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
package oop.Demo02;
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args) {
//类:抽象的,实例化
//类实例化后会返回一个自己的对象!
//student对象就是一个Student类的具体实例:
Student xm = new Student();
Student xh = new Student();
xm.name = "小明";
xm.age = 3;
System.out.println(xm.name);
System.out.println(xm.age);
xh.name ="小红";
xh.age = 3;
System.out.println(xh.name);
System.out.println(xh.age);
}
}
构造器的调用 必须掌握
package oop.Demo02;
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args) {
//实例化了一个对象
Person person = new Person("songchao");
System.out.println(person.name);//null
}
}
package oop.Demo02;
import com.sun.org.apache.xpath.internal.functions.FuncQname;
public class Person {
//一个类型即使什么都不写,它也会存在一个方法
//显示的定义构造器
String name;
//1使用new关键字,本质还是在调用构造器
//2用来初始化值
public Person(){
}
//有参构造:一旦定义了有参构造,无参就必须显示定义
public Person(String name){
this.name = name;
}
//alt + insert 生成构造器
}
/*
构造器:
1.和类名相同
2.没有返回值
作用;
1 new 本质在调用构造方法
2.初始化对象的值
注意点;
1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
Alt + Insert
this. 等于当前类 .是传进来的值
*/
简单小结类与对象
package oop;
import oop.demo03.Pet;
public class Application {
public static void main(String[] args) {
/*
1.类与对象
类是一个模板:抽象,对象是一个具体的实例
2.方法
定义,调用!
3.对应的引用
引用类型:基本类型有8钟
对象是通过引用来操作的:栈--->堆
4.属性:字段啊Field 成员变量
默认初始化:
数字:0 0.0
char: u0000
boolean:false
引用:null
修饰符 属性类型 属性名 = 属性值! 万能赋值公式
5.对象的创建和使用
- 必须使用new 关键字创造对象,构造器 Person songchao = new Person();
- 对象的属性 songchao.name
- 对象的方法 songchao.sleep()
6.类:
静态的属性 属性
动态的行为 方法
*/
}
}
面向对象三大特性 核心重点
封装
package 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;
}
}
}
package oop;
import oop.demo03.Pet;
import oop.demo04.Student;
/*
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
*/
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("宋超");
//方法名,参数列表
System.out.println(s1.getName());
s1.setAge(22);
System.out.println(s1.getAge());
}
}
继承
package oop.demo05;
//在Java中,所有的类,都默认直接或者间接继承Object
//Person 人 : 父类
public class Student extends Person {
}
extends//继承关键字
Super详解
super注意点
1.super调用父类的构造方法,必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造中!
3.super和 this 不能同时调用构造方法!
对比this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的引用
前提;
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法;
this();本类的构造
super();父类的构造!
方法的重写
重写都是方法的重写,和属性无关
重写:需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表,列表必须相同
3.修饰符:范围可以扩大但不能缩小:pubilc > Protected > Default > private
4.抛出的异常:范围,可以被缩小,但不能扩大;ClassNotFoundException --> Exception(大)
重写,子类的方法和父类必须要保持一致;方法体不同!
为什么需要重写;
1.父类的功能,子类不一定需要,或者不一定满足!
快捷键:Alt + Insert ; 选中override;
package oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
package oop.demo05;
//继承
public class A extends B{
//Override 重写
@Override//注解;有功能的注释!
public void test() {
System.out.println();
}
}
package oop.demo05;
public class Application {
//静态的方法和非静态的方法区别很大!
//静态方法://方法的调用只和左边,定义的数剧类型有关
//非静态:重写
public static void main(String[] args) {
A a = new A();
a.test();//A
//父类的引用指向了子类
B b = new A();// 子类重写了父类的方法
b.test();//B
}
}
多态
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了:父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的!
Student s1 = new Student();
//Person 父类型,可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法,主要看对象左边的类型,和右边关系不大!
//s2.eat();//子类重写了父类的方法,执行子类的方法
s1.eat();
}
}
/*
多态注意事项;
1. 多态是方法的多态,属性没有多态
2. 父类和子类,有联系 类型转换异常! ClassCastException!
3. 存在条件:继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();
有些方法不能被重写
1.static 方法,属于类,它不属于实例
2.final 常量:
3.private 方法;
*/
instanceof和类型转换
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//类型之间的转化: 父 子
//子类转换为父类,可能丢失自己的本来的一些方法!
Student student = new Student();
student.go();
Person person = student;
}
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型;
3.把父类转换为子类,向下转移: 强制转换
4.方便方法的调用,减少重复的代码! 简介
java核心思想 抽象
*/
static关键字详解
package 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(random());
System.out.println(PI);
}
}
package oop.demo07;
import com.sun.org.apache.xml.internal.res.XMLErrorResources_tr;
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 person1 = new Person();
System.out.println("==============");
Person person2 = new Person();
}
}
package oop.demo07;
//Static
public class Student {
private static int age;//静态的变量 多线程!
private double score; //非静态的变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
go();
}
}
抽象类和接口
package oop.demo08;
//abstract 抽象类:类 extends :单继承 (接口可以多继承)
public abstract class Action {
//约束~有人帮我们实现~
//abstract , 抽象方法,只有方法名字,没有方法的实现!
public abstract void doSomething();
//1.不能new这个抽象类,只能靠子类去实现它:约束!
//2.抽象类中可以写普通的方法~
//3.抽象方法必须在抽象类中~
//抽象的抽象:约束~
//思考题 既然不能new,那能存在构造器么?
// 抽象存在什么意义? 提高开发效率
}
接口的定义与实现 最重要核心中的核心
package oop.demo09;
//抽象的思维 Java 很难
//interface 定义的关键字
public interface UserService {
//属性默认是常量 public static final
int AGE = 99;
//接口中的所有定义的方法其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package oop.demo09;
public interface TimeService {
void timer();
}
package oop.demo09;
//抽象类:extends~
//一共类可以实现接口 通过implement 接口
//实现了接口的类,就需要重写接口中的方法~
//利用接口实现多继承~ 接口只有方法的定义
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
作用:
1.约束
2.定义一些方法,让不同的人实现~
3.public abstract
4.public static final
5.接口不能被实例化~,接口中没有构造方法~
6.implements可以实现多个接口
7.实现接口必须要重写接口的方法!