1 面向对象之类与对象
是抽象的概念,笼统的,不具体的 人类 狗类 鸟类
对象又叫实体,类的具体表现
人类中:厨师, 学生,老师
狗类:小狗1号,小黑狗
1.1 类的定义规范
[public] [abstract|final] class 类名class_name [extends 继承的类名] [implements 实现的接口名] {
属性类型1 属性名1;
属性类型2 属性名2;
public int add(int a,int b){
return a+b;
}
public static void speak(){
System.out.println("说话");
}
}
1.2 java类中的属性
[public|protected|private] [static][final] <变量类型> <变量名>
public protected private :用于表示成员变量的访问权限
static :表示该成员变量为类变量,也称为静态变量
final :表示将该成员变量声明为常量,其值无法更改
变量类型 :表示变量的类型
变量名:表示变量名称
public class Person{
public String name;
final int sex =0;
private int age;
static String shcool="清华";
}
1.3 创建一个类实例化得到对象
public class Demo01 {
public static void main(String[] args) {
Person p=new Person();
p.name="justin";
p.age=19;
System.out.println(p.name);
p.setSex(true);
p.getSex();
p.Speak();
}
}
class Person{
public String name;
public int age;
private boolean sex;
public boolean getSex(){
return this.sex;
}
public void setSex(boolean sex){
this.sex=sex;
}
public void Speak(){
System.out.println("人说话");
}
}
1.4 成员方法(类中定义的方法)
[public|private|protected] [abstract] [static|final] <void|return_type><方法名>([参数]) {
}
public private protected :表示成员方法的访问权限
abstract :表示限定该成员方法为抽象方法。抽象方法不提供具体的实现,并且所属类型必须为抽象类
static :表示限定该成员方法为静态方法(类的方法)
final :表示限定该成员方法不能被重写或重载
<void|return_type>:返回值是空或某个类型
1.5 构造方法
public class Demo02 {
public static void main(String[] args) {
Foo f = new Foo();
Foo f1 = new Foo("justin", 19);
Foo f2 = new Foo("justin");
System.out.println(f.name);
System.out.println(f1.name);
}
}
class Foo {
public String name;
public int age;
public Foo() {
}
public Foo(String name, int age) {
this.name = name;
this.age = age;
}
public Foo(String name) {
this.name=name;
}
}
1.6 this关键字
public class Demo02 {
public static void main(String[] args) {
Foo f2 = new Foo("彭于晏");
f2.speak();
}
}
class Foo {
public String name;
public Foo(String name) {
this.name=name;
}
public void speak(){
System.out.println("名字是:");
System.out.println(this.name);
System.out.println("在说话");
}
public void changName(String name){
this.name=name;
}
}
1.7 访问控制修饰符
public
不写(default)
public
不写(默认,default,friendly)
protected
private
访问范围 |
private |
friendly(默认) |
protected |
public |
同一个类 |
可访问 |
可访问 |
可访问 |
可访问 |
同一包中的其他类 |
不可访问 |
可访问 |
可访问 |
可访问 |
不同包中的子类 |
不可访问 |
不可访问 |
可访问 |
可访问 |
不同包中的非子类 |
不可访问 |
不可访问 |
不可访问 |
可访问 |
1.8 静态变量和静态方法
public class Demo03 {
public static void main(String[] args) {
Aoo a =new Aoo();
a.speak();
System.out.println(Aoo.getSchool());;
System.out.println(a.getSchool());;
a.school="复旦";
System.out.println(Aoo.getSchool());;
System.out.println(a.getSchool());;
}
}
class Aoo{
public String name;
public static String school="清华";
public void speak(){
System.out.println("说话");
}
public static String getSchool(){
return school;
}
}
2 面向对象之继承
2.1 继承格式
class 父类 {
}
class 子类 extends 父类 {
}
class 子子类 extends 子类 {
}

public class Demo04 {
public static void main(String[] args) {
Coo c =new Coo();
c.run();
}
}
class Boo{
public void run(){
System.out.println("走路");
}
}
class Coo extends Boo{
}
2.2 构造方法
public class Demo05 {
public static void main(String[] args) {
Eoo e=new Eoo();
System.out.println(e.name);
}
}
class Doo{
public String name;
public Doo(String name){
this.name=name;
}
}
class Eoo extends Doo{
}
2.3 super和this关键字
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类
this关键字:指向自己的引用
public class Demo06 {
public static void main(String[] args) {
Hoo h= new Hoo();
h.zzz();
}
}
class Goo{
public void xx(){
System.out.println("xx");
}
}
class Hoo extends Goo{
public void zzz(){
this.xx();
}
public void xx(){
System.out.println("asdfasdfasdfasdf");
}
}
3 重写和重载
被重载的方法必须改变参数列表(参数个数或类型不一样)
public class Demo07 {
public static void main(String[] args) {
}
}
class Xoo {
public void Speak() {
System.out.println("xoo的speak");
}
}
class Yoo extends Xoo {
@Override
public void Speak() {
System.out.println("Yoo的speak");
}
public void run(){
System.out.println("跑步");
}
public void run(String name){
System.out.println("跑步");
}
}
4 面向对象之接口
1 接口(Interface),是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过实现接口的方法,从而来实现接口
2 接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
3 接口无法被实例化,但是可以被实现
一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。
4 接口与类相似点:
一个接口可以有多个方法
接口文件保存在 .java 结尾的文件中,文件名使用接口名
5 接口与类的区别:
接口不能用于实例化对象
接口没有构造方法
接口中所有的方法必须是抽象方法
接口不能包含成员变量,除了 static 和 final 变量
接口不是被类继承了,而是要被类实现
接口支持多继承
4.1 接口声明
[可见度] interface 接口名称 [extends 其他的接口名] {
}
interface Duck{
public void Speak();
public void run();
}
4.2 接口继承
interface Duck{
public void Speak();
public void run();
}
interface PDuck{
public void Eat();
}
interface TDuck extends Duck,PDuck{
public void Fly();
}
4.3 接口实现
interface Duck {
public void Speak();
public void run();
}
interface PDuck {
public void Eat();
}
interface TDuck extends Duck, PDuck {
public void Fly();
public void run(String name);
}
class Woo implements Duck,TDuck {
@Override
public void Speak() {
System.out.println("speak具体实现");
}
public void Speak(String name) {
System.out.println("speak具体实现");
}
@Override
public void run() {
System.out.println("run具体实现");
}
@Override
public void Eat() {
}
@Override
public void Fly() {
}
@Override
public void run(String name) {
}
}
5 面向对象之抽象类
public class Demo09 {
public static void main(String[] args) {
Cat c =new Cat();
c.run();
c.Speak();
}
}
abstract class Animal{
public abstract void Speak();
public void run(){
System.out.println("小跑");
}
}
class Cat extends Animal{
@Override
public void Speak() {
System.out.println("说胡话");
}
}
6 面向对象封装
python 使用 __开头 属性或方法就是隐藏
java private 修饰,只能在类内部使用,外部不能使用
set变量名
get变量名

public class Demo10 {
public static void main(String[] args) {
Dog d = new Dog();
d.name = "小野狗";
System.out.println(d.name);
d.setAge(999);
System.out.println(d.getAge());
}
}
class Dog {
public String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 100) {
System.out.println("不允许大于100");
} else {
this.age = age;
}
}
}
7 多态
动物: 狗 猫 人
都可以走路: 动物对象.走路()
狗.走路()
(1)编写具有继承关系的父类和子类
(2)子类重写父类方法
(3)使用父类的引用指向子类的对象
public class Demo11 {
public static void main(String[] args) {
Dog1 dog = new Dog1();
Cat1 cat = new Cat1();
Animal1 a = dog;
a = cat;
animalRun(a);
}
public static void animalRun(Animal1 obj){
obj.run();
}
}
class Animal1 {
public void run() {
System.out.println("AAA的run");
}
}
class Dog1 extends Animal1 {
public void run() {
System.out.println("Dog1的run");
}
}
class Cat1 extends Animal1 {
public void run() {
System.out.println("Cat1的run");
}
}
8 枚举类型
一年的 4 个季节
一年的 12 个月份
性别有男,女,未知
public class Demo12 {
public static void main(String[] args) {
System.out.println(Sex.Female);
System.out.println(Sex.UnKnown);
System.out.println(Sex.Male);
}
}
enum Sex {
Male,
Female,
UnKnown
}
9 包
- 同一个包下,不能命名出同名的类
-不同包下,可以有同名的类
1、把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用
2、同文件夹一样,包采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。因此,包可以避免名字冲突。
3、包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
import com.justin.aaa.Animal;
public class Demo13 {
public static void main(String[] args) {
Animal a =new Animal();
a.name="xxx";
a.SpeakName();
com.justin.bbb.Animal b = new com.justin.bbb.Animal();
b.run();
}
}
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)