面向过程:procedure oriented programming 缩写 POP
分析出解决问题所需要的步骤 然后把步骤一步一步实现
面向过程直接关注流程
面向对象:object oriented programming 缩写 OOP
以分类的方式进行思考和解决问题
面向对象先对整体关系作出分类 然后根据不同的类深入细节的处理。
面向对象的思想符合人类的认知习惯
java类概念:对现实事物的抽象 实际生活中 先有对象后有类(概念)
结构:
①成员变量(事物属性的描述)
②方法(事物的行为功能)
③构造方法(用于创建对象)
④代码块
⑤内部类
三步走
第一步:发现类
[访问权限修饰符][修饰符] class 类{
}
//有public修饰的类 类名与文件名一致
//无public修饰的类 类名可与文件名不一致
第二部:定义类的成员变量(共有属性)
String name; String hobby; int height; int weight; String character;
第三部:定义类的成员方法(功能/行为)
public void study(){
System.out.println(name+"热爱学习");
}
public void play(){
System.out.println(name+hobby);
}
总结类和对象:
类:对现实事物的抽象 是模块 模型
对象:从类中创建的
成员变量
定义在类中 方法体之外
数据类型可以是java中的任意类型
成员变量可以初始化 也可以不初始化(不初始化则使用默认值)
创建对象时 会从类中向对象中复制一份成员变量
在构造方法 成员方法 代码块中可以使用成员变量
局部变量
定义在方法 构造方法 代码块之外
数据类型可以是java中的任意类型
使用前必须初始化赋值
形参也属于局部变量
局部变量仅在该方法中调用 方法结束后自动销毁
成员方法
定义在类中 没有被static修饰
通过对象调用
构造方法
作用:用来初始化新构建的对象
特点:
①构造方法名与类名相同 没有返回值 且不需要void修饰
②每个类中都至少有一个构造方法 也可以定义多个
每创建一个对象时 至少调用一个构造方法
如果类中无构造方法 会默认提供一个构造方法
一旦定义有参的构造方法 默认的失效
方法重载
在同一个类中 有多个方法名相同 但参数不同的方法
区分条件:参数个数 参数类型 参数顺序
方法重载与返回值无关
成员方法也可以重载
package day2;
public class Demo1 {
public Demo1(){
System.out.println("无参的构造方法");
}
public Demo1(String n,String s){
System.out.println("有2个参数的构造方法");
System.out.println("方法类型:string string");
System.out.println(n+"t"+s);
}
public Demo1(String n,int a){
System.out.println("有2个参数的构造方法");
System.out.println("方法类型:string int");
System.out.println(n+"t"+a);
}
public Demo1(String n,int a,float f){
System.out.println("有3个参数的构造方法");
System.out.println("方法类型:string int float");
System.out.println(n+"t"+a+"t"+f);
}
public static void main(String[] args) {
String name;
String sex;
int age;
float wight;
Demo1 test1 = new Demo1();
Demo1 test2 = new Demo1("包子", "女");
Demo1 test3 = new Demo1("包子", 20);
Demo1 test4 = new Demo1("包子", 20, 98);
}
}
值传递和引用传递
基本类型:值传递
引用类型:地址传递
对象与引用this关键字
当变量名与成员变量名一致时 this表示当前正在 *** 作的对象
语法:this.成员变量名
用于区分成员变量和局部变量
static关键字概念:静态的 可以用来修饰属性,方法,代码块,内部类
特点:被static修饰的内容
①随着类加载而加载
②优先于对象存在
③可以被所有对象共享
④可通过对象名直接调用
package day3;
import day1.ZhengHun;
public class StaticPro {
String name; //不建议使用static修饰 因为name每个对象不同
int age;
static String country = "中国"; //常量
public void test() { //无static修饰可调用以上属性
System.out.println(name);
System.out.println(country);
}
public static void test2() { //static修饰方法,类方法
// System.out.println(name); //报错 static优于对象存在
System.out.println(country);
}
public static void main(String[] args) {
StaticPro zs = new StaticPro();
zs.name = "张三";
zs.age = 20;
zs.test();
System.out.println(StaticPro.country); //静态资源随着类加载而加载 可直接调用
StaticPro ls = new StaticPro();
ls.name = "李四";
ls.age = 21;
ls.test();
}
}
代码块
概念:类似一个没有名字的方法
分类:
实例代码块(在创建对象之后执行)
静态代码块(在类加载时执行)
类什么时候加载?
①main方法在哪个类中执行 该类加载
②创建某个类的对象时
③调用某个类中静态属性,方法
注意:若只使用类中的静态常量 不加载整个类(final static)
package day3;
public class DaiMaKuai {
static String country = "China";
int age = 10;
{
System.out.println("实例代码块"); //调用构造方法后调用 创建一次对象就调用一次
}
static{
System.out.println("静态代码块1"); //只执行一次 先于非静态
}
static{
System.out.println("静态代码块2"); //有多个静态时按先后顺序执行
}
public static void main(String[] args) {
new DaiMaKuai();
new DaiMaKuai();
System.out.println(DaiMaKuai.country);
new DaiMaKuai();
new DaiMaKuai();
}
}
包(package)
概念:为了更好的组织类 java提供了包机制 用于区别类名的命名空间
作用:避免类重名 按功能管理类 控制访问权限
命名规则:
①包名小写
②项目类型:com(商业的) org(非盈利组织) edu(教育) gov(政府)
③公司名称:huawei sun
④项目名称:oa erp cms
⑤功能模块:窗口/视图层 数据访问层 服务层 工具类
访问权限修饰符作用:修饰类,成员变量,成员方法,内部类 控制对其访问的权限(与包密切相关)
访问权限(成员变量 成员方法)
概念:
概念:将类的某些信息隐藏在类内部(用访问权限修饰符来实现)
不让外部直接对其访问 可以通过特定方法对隐藏信息进行访问 便于控制
package edu.ffyc.javaOOP.FengZhuang;
public class Demo {
private String name;
public Demo(){
}
public Demo(String name){
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
}
package edu.ffyc.javaOOP.FengZhuang;
public class TestDemo {
public static void main(String[] args) {
Demo zrx = new Demo();
zrx.setName("小张");
System.out.println(zrx.getName());
}
}
扩
设计模式:解决某一类问题的方案(模式)
单例模式:让一个类在一个程序只能建造一个对象
步骤:
将构造方法私有化 使其在其他类中不能随便使用
提供一个方法 用static修饰
package edu.ffyc.javaOOP.DanLi;
public class Demo{
private static Demo li = null;
private Demo(){
}
public static Demo getDanLi(){
if (li == null){
li = new Demo();
return li;
}
return li;
}
}
package edu.ffyc.javaOOP.DanLi;
public class TestDemo {
public static void main(String[] args) {
System.out.println(Demo.getDanLi());
}
}
继承
概念:子承父类 实现代码重用 父类/基类---->子类/派生类
条件:两者属于同一类 是is-a关系
作用:①实现代码重用 ②扩展性好:子类除了继承父类的功能外 还可以扩展自己的功能
继承:
①关键字:extends
②子类可以访问父类中的所有非私有属性和方法
③将子类的共有属性存放在父类中
④一个子类只能继承一个父类
⑤子类中可以扩展特有属性和方法
传递性:
①C继承B B继承A 则C可以调用A,B中的非私有属性和方法
②当一个类没有显示的继承某个类时 那么这个类默认继承Object类(所有类的基类)
package edu.ffyc.javaOOP.extends_person;
public class Person { //父类是Object类
private String name;
private int age;
public void play(){
System.out.println("贪玩是人的天性");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package edu.ffyc.javaOOP.extends_person;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.sql.SQLOutput;
public class Student extends Person{ //父类是Person类
private String hobby;
public void flag(){
System.out.println("好好学习,天天向上");
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
package edu.ffyc.javaOOP.extends_person;
public class Zhang extends Student{ //父类是Student类
String sex;
public void work(){
System.out.println("写代码使人秃头");
}
}
package edu.ffyc.javaOOP.extends_person;
public class Test {
public static void main(String[] args) {
//调用父类的父类中的属性和方法
Person person = new Person();
person.setName("小张");
person.setAge(20);
System.out.println("姓名:"+person.getName());
System.out.println("年龄:"+person.getAge());
person.play();
//调用父类中的属性和方法
Student student = new Student();
student.setHobby("敲代码");
System.out.println("他的爱好是"+student.getHobby());
student.flag();
//调用自己的属性和方法
Zhang zrx = new Zhang();
zrx.sex = "男";
System.out.println("性别:"+zrx.sex);
zrx.work();
}
}
继承中的构造方法:
在创建子类对象后 调用构造方法时从上向下的调用 先初始化父类
使用super()在子类构造方法中第一行默认执行 调用父类的构造方法
package edu.ffyc.javaOOP.extends_person;
public class Person { //父类是Object类
private String name;
private int age;
//继承中的构造方法
public Person(){
System.out.println("Person类的无参构造方法");
}
public Person(String name){
System.out.println("Person类的有参构造方法");
}
}
package edu.ffyc.javaOOP.extends_person;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.sql.SQLOutput;
public class Student extends Person{ //父类是Person类
private String hobby;
public Student(){
System.out.println("Person类的无参构造方法");
}
public Student(String name){
super(name);
System.out.println("Person类的有参构造方法");
}
}
package edu.ffyc.javaOOP.extends_person;
public class Zhang extends Student{ //父类是Student类
String sex;
public Zhang(){
System.out.println("Person类的无参构造方法");
}
public Zhang(String name){
super(name);
System.out.println("Person类的有参构造方法");
}
public void work(){
System.out.println("写代码使人秃头");
}
}
package edu.ffyc.javaOOP.extends_person;
public class Test {
public static void main(String[] args) {
//调用自己的属性和方法
Zhang zrx = new Zhang();
zrx.sex = "男";
System.out.println("性别:"+zrx.sex);
zrx.work();
Zhang zhang = new Zhang("小张");
}
}
输出结果为
方法的重写:
原因:父类中的实现方式不能满足子类的需求
解决:在子类中对父类的方法进行重写(覆盖)
具体语法:
方法名,参数列表,返回值类型相同
访问权限修饰符不能小于父辈
@Override:添加此注解的标签表示此方法是从父类重写过来的 会进行语法验证
package edu.ffyc.javaOOP.extends_person;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.sql.SQLOutput;
public class Student extends Person{ //父类是Person类
public void flag(){
System.out.println("好好学习,天天向上");
}
}
package edu.ffyc.javaOOP.extends_person;
public class Zhang extends Student{ //父类是Student类
public void work(){
System.out.println("写代码使人秃头");
super.flag(); //调用父类中的flag方法
}
@Override //验证重写方法
public void flag(){
System.out.println("做一个码农");
}
}
package edu.ffyc.javaOOP.extends_person;
public class Test {
public static void main(String[] args) {
Zhang zrx = new Zhang();
zrx.work();
zrx.flag(); //调用的是Zhang类中重写的flag方法
}
}
抽象类(abstract)
概念:抽象类是一个类 是抽象的 即概念的
抽象方法:只有声明 没有实现 即没有实现体
public abstract void person(); //无实现体即为抽象方法 抽象方法需要用abstract修饰
注意事项:
①abstract修饰的方法是抽象的 没有方法体
②在一些靠近顶层的类 他的实现与大多数子类不同 此时没有必要在顶层实现 只需要声明功能即可
③如果一个类继承了抽象类 要么重写抽象类中的所有抽象类 要么将此类也设置为抽象类
抽象类:
①用abstract修饰 抽象类中可能包含了抽象方法
②如果一个类中没有足够的信息(抽象方法)来描述一个具体的对象 这样的类就是抽象类
③抽象类不能创建对象(因为其中包含了抽象方法) 其他功能与类相同(成员变量 成员方法 构造方法)
④抽象类一般位于体系结构的上层 用来定义功能
有抽象方法的类必为抽象类
抽象类中可能包含抽象方法
package edu.ffyc.javaOOP.chouxiang;
public abstract class Abstract {
String name;
public abstract void race();
}
package edu.ffyc.javaOOP.chouxiang;
public class ZRX extends Abstract{
public void race(){
System.out.println(name+"是一个神灵");
}
}
package edu.ffyc.javaOOP.chouxiang;
public class Test {
public static void main(String[] args) {
ZRX zrx = new ZRX();
zrx.name = "小张";
zrx.race();
}
}
多态
概念:同一种事物在不同时刻有不同的表现不同的状态
条件:
①要有继承关系(类继承类 类继承抽象类 类实现接口)
②要有方法重写
③父类的引用指向子类对象
注意:
针对非静态成员方法:编译看左边 运行看右边
针对静态方法 成员变量:编译运行都看左边
优点:父类引用指向子类对象 提升程序的扩展性
缺点:父类不能调用子类中特有的功能
解决:多态转型
多态转型自动转型:子继承父(向上转型)
强制转型:向下转型(父类类型转为子类自己的类型)
//父类
package edu.ffyc.javaOOP.duotai;
public abstract class Person {
String name;
int age;
public abstract void study();
}
//子类
package edu.ffyc.javaOOP.duotai;
public class Student extends Person{
@Override
public void study() {
System.out.println(name+"热衷于敲代码");
}
//子类中特有的方法 多态无法自动转型(即多态的缺点)
public void grade(){
System.out.println(name+"的考试成绩为100分");
}
}
//子类
package edu.ffyc.javaOOP.duotai;
public class Worker extends Person{
@Override
public void study() {
System.out.println(name+"积极实现自己的价值");
}
}
package edu.ffyc.javaOOP.duotai;
public class Test {
public static void main(String[] args) {
Person z = new Student(); //多态 父类的引用指向子类对象 自动转型
z.name = "小张";
z.age = 20;
z.study();
Student student = new Student();
Worker worker = new Worker();
student.name = "小新";
worker.name = "小瑞";
Test t = new Test();
t.wishPerson(student);
t.wishPerson(worker);
}
//多态 执行父类方法
public void wishPerson(Person person){
person.study();
}
//多态 执行子类中特有的方法
public void willPerson(Person person){
if(person instanceof Student){ //判断Person类(父类)中实际传入的类型是什么
Student student = (Student)person; //强制转换 之后可调用子类中特有的方法
student.study();
}
}
}
接口
生活中的接口:USB接口
接口:类似于抽象类 可以看做是一个彻底的抽象类
接口和抽象类:都是用于在顶层类中指定规范(设计功能)
设计接口:
interface关键字
接口中没有构造方法
不能创建对象
规则:
一个接口可以继承多个窗口
一个类可以实现多个接口
一个类只能直接继承一个类
package edu.ffyc.javaOOP.jiekou;
public interface Person extends PersonA,PersonB{ //一个接口可以继承多个接口
// public static final int age = 20; 成员变量默认为静态常量
int age = 20;
// public abstract void study(); 接口定义抽象方法
void study();
void eat();
//静态方法 直接通过接口名调用
public static void testStatic(){
System.out.println("接口静态方法");
}
//默认方法 通过子类对象调用
public default void testDefault(){
System.out.println("接口默认方法");
}
}
package edu.ffyc.javaOOP.jiekou;
public interface PersonA {
void eat();
}
package edu.ffyc.javaOOP.jiekou;
public interface PersonB {
}
package edu.ffyc.javaOOP.jiekou;
public class Student implements Person{
@Override
public void study() {
System.out.println("好好学习 天天向上");
}
@Override
public void eat() {
}
}
package edu.ffyc.javaOOP.jiekou;
public class Test {
public static void main(String[] args) {
Person person = new Student();
person.study(); //抽象方法 通过对象调用
Person.testStatic(); //静态方法 直接接口名调用
person.testDefault(); //默认 通过对象调用
System.out.println(Person.age); //接口中的常量
}
}
final关键字
修饰类-------->该类不能被其他类继承
修饰方法------>该方法不能被重写
修饰属性------>该属性为常量 创建时需要赋值 赋值后值不能改变
package edu.ffyc.javaOOP.finaldemo;
public class Person {
// public class Person extends String{ 注意:String默认为final修饰 不能继承
static final int a = 10; //定义之初进行赋值 之后所有对象不能改变其值 建议用static修饰
final int b; //在定义之初没有赋值 那么必须在构造方法为其赋值
public Person(int b){
this.b = b;
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）