面向对象2

最新推荐文章于 2024-10-30 18:07:32 发布

@GTR

最新推荐文章于 2024-10-30 18:07:32 发布

阅读量38

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_55849631/article/details/121995588

版权

Java面向对象2
目标：
●对象与引用
●static关键字
●代码块
●包
●访问权限修饰符
●面向对象特征–封装
●this关键字

对象与引用：
Java 语言中除基本类型之外的变量类型都称之为引用类型。Java中的对象是通过引用对其操作的.
例如：我们有一个自定义类为Car（汽车类）
class Car{
String color;
String name;
String model;
}
Car car= new Car();
通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作。
1）右边的“new Car()”，是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象。
2）左边的“Car car”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指向Car
对象的对象引用。
3)”=”操作符使对象引用指向刚创建的那个Car对象。
我们可以把这条语句拆成两部分：
Car car;
car= new Car();
这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。

new Car(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。
Car car1;
Car car2;
car1 = new Car();
car2 = car1 ;
（1）创建一根绳子，一根还没有系上任何一个汽球的绳；
（2）就又做了一根绳，还没系上汽球，
（3）给car1 系上气球；
（4）这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。结果是，car2也指向了car1所指向的对象。两根绳系的是同一只汽球

值传递与引用传递:
Java中进行方法调用中传递参数时，参数传递有两种：
值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实
际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形
式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下
来，所以方法执行中形式参数的改变将会影响实际参数。
public class text {
public static void main(String[] args) {
text t1 = new text();
int a = 10;
t1.m1(a);
System.out.println(“a”+a);//10

}
public void m1(int b){
//基本数据类型，传过去的是地址，不会改变a的值
System.out.println("b1:"+b);//10
b = 20;
System.out.println("b2:"+b);//20
}
/*
值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，
形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

public class text2 {
public static void main(String[] args) {
Dog xh = new Dog();
xh.name = "小黑";
text2 t2 = new text2();
t2.m1(xh);
System.out.println("xh:"+xh.name);
}
public void m1 (Dog dog){
//引用数据类型，传递的是他的地址，会改变基本数据类型的值
System.out.println(dog.name);
dog.name = "旺财";
System.out.println(dog.name);
}
}
class Dog{
String name;
}
引用传递：(形参数类型是引用数据类型参数)：也称为传地址。
方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数

static 关键字:## 标题
static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。
1.随着类的加载而加载
2.优先于对象存在
3.修饰的成员，被所有对象所共享
4.可不创建对象，直接被类调用
静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用在static方法内部只能访问类的static属性，不能访问类的非static属性,static属
性先加载。

static String contry = "";
int age;
public void m2(){

}

public static void main(String[] args) {
Static s1 = new Static();
s1.age =10;
s1.contry="";//赋值会改变成员变量的值
System.out.println(Static.contry);
// static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用

//在static方法内部只能访问类的static属性，不能访问类的非static属性,static属性先加载。
Static s2 = new Static();
s2.num = "11111";
System.out.println(s2.num);

Static s3 = new Static();
System.out.println(Static.num);
//调用static修饰的成员变量改变他的值时，是会改变其地址的值，所以成员变量中static修饰的值也跟着改变

代码块 :
**
代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块
实例块：每次创建对象时自动调用
{
//任何符合语法的Java代码
}
静态块：类加载时自动调用，仅一次，与是否创建对象无关。
static {
//任何符合语法的Java代码
}
public class demo4 {
/*
代码块定义在类中，类似于一个没有名称的方法体
代码块分为
实例代码块和静态代码块

实例代码块：
{
//任何java语句
}

静态代码块：
static{
//任何java语句
}

*/
static String name = "zhangsan";
{
System.out.println("代码块1");
}

{
System.out.println("代码块2");
}

static{
System.out.println("静态代码块1");
}

static{
System.out.println("静态代码块2");
}
public demo4(){
System.out.println("无参构造方法");
}
//那么实例代码块和静态代码块什么时候会加载呢？

//1.在调用类的方法时，会执行代码块
public static void main(String[] args) {
//在调用类的方法时，会执行代码块
demo4 d4 = new demo4();
//并且静态先执行，后执行实例代码块
System.out.println("-----------");

demo4 d5 = new demo4();
//实例代码块是调用几次执行几次
//而静态代码块只会执行一次
System.out.println("------");
System.out.println(demo4.name);
}

//2.
//因为static修饰的代码块会先加载，
//所以在加载main方法时，会自动运行一次静态代码块
//类加载时自动调用，仅一次，与是否创建对象无关。
/*public static void main(String[] args) {

}

包和权限修饰符:

public class demo5 {
/*
包：
包的概念：就是文件夹

包的作用：避免类重名
按照不同功能管理类
控制访问权限
*/
//控制访问权限：
//public protected (default) private

/*
public：公共的修饰类，属性，方法。可以被任意类访问
protected：受保护的权限修饰属性、方法。可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
（default）：同包权限修饰类、属性、方法。只能被同包的类访问
private：私有权限修饰属性、方法。只能在本类中访问
*/
public String name1 = "name1";
protected String name2 ="name2";
String name3 = "name3";
private String name4 = "name4";

public demo5(){//默认无参构造方法

}
public static void main(String[] args) {
demo5 d5 = new demo5();
System.out.println(d5.name1);
System.out.println(d5.name2);
System.out.println(d5.name3);
System.out.println(d5.name4);
//同包同类可以随意访问4种访问权限修饰符修饰的方法、变量、类

}
}
class demo6{
public static void main(String[] args) {
demo5 d5 = new demo5();
System.out.println(d5.name1);
System.out.println(d5.name2);
System.out.println(d5.name3);
//System.out.println(d5.name4);
//在同包不同类中，只有被private修饰的类、方法、变量不可被访问，其余三个都可以
}
}
//继续记包：
/*
包（package）的命名规范：
在包名中，可以使用.号来区分包的级别；
包名一般情况下是小写
第一级指该项目的类型，如com,org,gov等，
第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei 等
第三级指项目的名称，如：bcms,oa,erp,cms等
第四级指项目模块的名称，如：bean,action,exception等
一个合格的包名至少有4个级别
*/
/*
包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限
导入外部的包类：关键字“import”
但是，long包在使用的时候可以不用导入，比如我们经常用的字符串类型String就是long包的引用类型
还有，import导入外来的包时，不可以导入类名不同，方法名相同的包，会报错
*/
public class demo5text {
public static void main(String[] args) {
demo5 d5 = new demo5();
System.out.println(d5.name1);
//System.out.println(d5.name2);
//System.out.println(d5.name3);
//System.out.println(d5.name4);
//在不同包的其他类中，只有public修饰的类、方法、变量才会被调用
}
}
//但是
class demo5text2 extends demo5{
public static void main(String[] args) {
demo5text2 d5 = new demo5text2();
System.out.println(d5.name1);
System.out.println(d5.name2);
//protected 可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
//子类继承其父类

//System.out.println(d5.name3);
//System.out.println(d5.name4);
}
}

面向对象特征–封装：
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问而是通过该类提供的方法来实现对隐藏信息的操作和访问。

public class text {
private String name;
private int age;
public text(){//私有的构造方法，外界不能调用、修改

}

public void getname(){//返回name
System.out.println(name);
}//放回姓名
public void getage(){//返回age
System.out.println(age);
}//返回年龄

public void ChangeName(String name){//修改名字的方法，只能用一次
if(name!=null && name.length()<5){
this.name = name;//this.name就是指出调用的对象，从而不会使控制台混淆
}
}

public void ChangeAge(int age){//修改年龄的方法，只能用一次
if((age>=0&&age<=120) && age!=0){
this.age =age;
}
}
}
class text2{
public static void main(String[] args) {
text t1 = new text();
t1.ChangeAge(18);
t1.ChangeName("王");
t1.getage();
t1.getname();
}
}