目录
面向过程
面向对象
java类
java类定义
java对象
变量分类
方法分类
重载和重写
对象与引用
代码块
包(package)
访问权限修饰符
封装
继承
多态
抽象类
接口
面向过程
procedure oriented programming 缩写 POP(分析解决问题的步骤,然后逐步解决问题的流程)
面向对象project oricented programing 缩写 OOP( 将问题进行分类解决)
以对象为核心，该方法认为程序由一系列对象组成
例如，对于一个学校学生管理系统来说，无论是简单还是复杂，始终是围绕学生和老师这两个客体实施。在自然界，每个客体都具有一些
属性和行为，例如学生有学号、姓名、性别等属性，以及上课、考试、做实验等行为。因此，每个个体都可以用属性和行为来描述。
java类类 它是描述一类事物属性和行为的集合
一个类中包含有:成员变量,方法,构造方法,内部类,块
public class Car{//汽车类,类似于汽车图纸
String name;//成员变量
String color;
int price;
//都是它的一些属性
public Car(){
//无参的构造方法
}
public void run(){
//它具有跑的方法
}
class NewCar{
//内部类
}
static{
//块
}
}
java类定义
声明格式:[访问权限修饰符] [修饰符] class 类名{}
访问权限修饰符:默认,public两种
修饰符:final与abstract
关键字:class
命名:首字母大写,见名知意
java对象对象:是类的一个实例,以类为模板在内存中创建的一个实例
对象的创建和使用: 类名 变量名 = new 类名();
一个类可以创建多个对象,他们共用类中的方法
现实生活中现有对象后又类,而编程时先有类后有对象
变量分类成员变量:定义在类中,方法体之外的变量
局部变量:定义在方法,构造方法,语句或者块中的变量
局部变量声明时必须赋值,而成员变量在声明时可以不对其进行初始化
局部变量只能在方法中使用,而成员变量可以被类中的方法,构造方法等访问
它们的类型都可以是基本类型或者是引用类型
方法分类成员方法:定义在类中的方法
public class Dog {
String name;
int age = 10;
public void show(){ //成员方法
System.out.println("名字:"+name+" 年龄:"+age);
}
}
构造方法:初始化对象的方法
public class Dog {
String name;
int age = 10;
public Dog() { //无参的构造方法
//与类名相同,不需要返回值和void修饰
}
public Dog(String name,int age) { //有参的构造方法
this.name = "旺财";
this.age = 20;
}
}
每一个类中,都具有构造方法,即使没有特地的显示出来,也会提供一个默认的执行
一个类中也可以有多个构造方法,根据他们的参数类型,顺序,个数不同构成了方法的重载.
重载和重写重载:Overload,一个类中如果有同名的方法,但是它们的参数列表不同,视为重载
* 方法的重载和方法的返回值类型没有关系
public class Dog {
//成员变量(也称为属性)
String name;
int age;
String color;
public void eat(){
int age = 5;//局部变量
System.out.println("吃了狗粮");
}
public void play(String name){
System.out.println(name + "玩飞盘");
System.out.println(this.name + "玩飞盘");
}
public void play(String name,int age){ //重载
System.out.println(name + "玩飞盘" + "年龄" + age );
}
}
class Test {
public static void main(String[] args) {
Dog d1 = new Dog();
d1.eat();
d1.play("二哈",3);
}
}
重写:Override,发生在父类和子类之间,父类不满足子类的需求,子类把父类已有的方法重新写了一遍,叫做重写
-
重写是方法的重写,和属性无关
-
非静态的方法可以重写
-
需要有继承关系,子类重写父类,
-
方法名,参数列表必须相同
-
为什么要重写:
-
父类的功能子类不一定需要,或者不一定满足
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
//父类引用指向子类
//父类可以指向子类,但是不能调用子类方法
Person s2 = new Student();
Object s3 = new Student();
s2.print(); //子类重写父类方法,执行子类的方法
s1.print();
Person teacher = new Teacher();
teacher.eat();
}
}
abstract class Person {
public void print(){
System.out.println("print");
}
public abstract void eat();
}
class Student extends Person{
@Override//重写父类方法
public void print() {
System.out.println("儿子");
}
@Override
public void eat() {
}
}
对象与引用
public class Person{
String name;
int age;
}
class Test{
public static void main(String [] args ){
Person person = new Person();
//此时的person就是创建的对象,可以访问Person类中的方法和属性
}
}
new person(); 我们是在堆空间中开辟了一块空间,创建了一个实体
在java中调用方法传递参数时,有两种方式值传递和地址传递
值传递: 形参类型是基本数据类型,传递的是数据本身
地址传递:形参类型是引用数据类型,传递的是对象的引用,而不是对象本身
代码块代码块:类似于一个没有名字的方法 实例代码块:创建对象后执行,创建一个对象就会执行依次 静态代码块:类加载而加载,只执行一次
{
System.out.println("执行了实例代码块");
}
static {
System.out.println("执行了静态代码块");
}
包(package)
为了更好的组织类,提供了包机制
命名:都是小写
命名规范:项目类型,公司名称,项目名称,功能模块
访问权限修饰符访问权限修饰符:
public:公共的 所有类中都可以访问到
protected:受保护的 不可以在不同包不同类中访问
default:默认的 只能在当前包和当前包中访问
private:私有的 只能在当前类中访问
封装将类的某些信息进行隐藏,不允许外部程序直接进行访问,而是通过该类提供的方法来进行访问
public class Demo03 {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
class Test {
public static void main(String[] args) {
Demo03 s2 = new Demo03();
s2.setName("小红");
System.out.println(s2.getName());
}
}
继承
继承:extends"扩展",子类是父类的扩展
-
java中只有单继承,没有多继承
-
类与类之间的关系,类与类之间还有:依赖,组合,聚合
-
*子类继承父类就会拥有父类的全部非私有方法
-
在java中所有类都默认继承Object类
-
私有的东西无法被继承(private修饰的)
public class Person {//父类
protected String name;
public Person() {
System.out.println("执行了父类的无参构造");
}
public void say(){
System.out.println("说了一句话");
}
}
class Teacher extends Person{//子类
int age;
}
public class Test {
public static void main(String[] args) {
Teacher teacher = new Teacher();
teacher.say();
}
}
多态
多态:同一事物,不同时刻的不同表现状态
多态是方法的多态,属性没有多态
父类引用指向子类,父类可以指向子类,但是不能调用子类方法
多态转型:向上转型,子类型 自动转为父类(Animal dog = new Dog();)
public abstract class Person {
public void print(){
System.out.println("print");
}
public abstract void eat();
}
class Teacher extends Person{
@Override
public void eat() {
System.out.println("老师类重写人类方法");
}
}
抽象类
抽象方法:只有声明,没有具体实现
abstract修饰的方法是抽象方法,没有方法体
1.不能new,只能靠子类去实现它.
2.抽象方法必须在抽象类中,抽象类中可以有普通方法
public abstract class Person {
public abstract void speak();
}
abstract class Chinese extends Person{
@Override
public void speak(){
}
}
接口
作用 定义一些方法,让不同的人实现,不能被实例化,接口中没有构造方法,implements可以实现多个接口
interface:定义的关键字
接口声明的默认属性 public static final
实现接口的类,必须重写接口中的方法,否则类必须定义为抽象类
一个类可以实现多个接口
一个接口可以继承多个接口
public interface Animal {
void eat();
}
class Dog implements Animal{ //implements实现接口
@Override
public void eat() {//实现接口的方法
System.out.println("小狗吃骨头");
}
}
class Cat implements Animal{
@Override
public void eat() {
System.out.println("小猫爱吃鱼");
}
}
class Test {
public static void main(String[] args) {
Dog dog = new Dog();
Cat cat = new Cat();
Test t = new Test();
t.animal(dog);
t.animal(cat);
}
public void animal(Animal animal){
animal.eat();
}
}
抽象类与接口的区别
1.抽象类中可以有默认方法的实现,但是接口中不可以
2.抽象类实现子类extends来继承,而接口是implements来实现接口
3.抽象类中可以有构造器,接口中不能有
4.抽象类修饰符可以有public,protected,default.而接口默认修饰符Public不能使用其它修饰符
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）