day06
一.匿名对象
1.定义:没有名字的对象。
2.意义:节省代码,并且很多情况下是针对某个方法只需要调用一次的情况下。
3.作用:(1)可以调用方法。
(2)可以给成员变量赋值。
(3)可以作为方法的参数进行传递。
4.主要作用:节省代码量,使代码结构更优雅。
二.封装
1.概念:隐藏对象的属性和细节,仅对外提供公共的方法进行访问。
2.(1)private
a.当类的成员变量使用private修饰符修饰,那么就不可以直接访问到该成员变量。
b.当使用private修饰的成员变量或者方法,仅能在本类中使用。
c.private对于main()方法的修饰,也是可以产生作用的。
(2)javaBean
是这样一类的类:
它的所有成员变量都使用private进行修饰,并且对外提供可访问的设置值和获取值的set,get方法。
不同的应用场景,可能命名不同。数据库中的应用称为POJO类。
(3)main方法细节:
a.每个类中都可以存在main()方法,但是执行的时候,会优先查看public的class中是否有main()方法。
b.如果没有public的class,那么会按照文件名优先查找类中的main()方法。
c.必须定义为public。
例子:
public class Demo1{
public static void main(String[] args){
/*
Person person = new Person();
person.name="diffo";
person.age = 20;
person.speak();
*/
//new Person("diffo",20).speak();
Person person = new Person();
person.initPerson(person);
person.speak();
initPerson(new Person()).speak();//参数为匿名对象
}
//定义的名称,是针对person对象初始化的。
static Person initPerson(Person person){
person.name="diffo";
person.age = 22;
return person;
}
}
class Person{
String name;
int age;
Person(){
//默认构造器
}
Person(String nameParm,int ageParm){//构造器
name = nameParm;
age = ageParm;
}
void initPerson(Person person){
person.name="diffo";
person.age = 22;
}
void speak(){
System.out.println("speak!: "+name+" . "+age);
}
}
三.优先原则
对于一个方法说,如果传递的形参的变量名称和类的成员变量名称相同,虚拟机会优先当做方法的形参来处理。
四.this关键字
1.含义:代表了当前对象的引用。
可以理解为,当前谁来调用,this就代表谁。
2.用法:a.对于成员变量可以区分出来的场景,this可加也可以不加,实际效果相同。
但是对于实现javaBean/POJO来说,我们建议都加上在setXXX,getXXX方法中。
b.this可以加在成员变量前面来指定对应的引用,也可以加在成员方法的前面。
例子:
//java bean
class Person{
private String name;
private int age;
void setName(String nameParm){
name = nameParm;
}
String getName(){
return name;
}
void setAge(int ageParm){
age = ageParm;
}
int getAge(){
return age;
}
void speak(){
System.out.println(name+" . "+age);
}
public static void main(String[] args){
Person person = new Person();
person.setName("diffo");
person.setAge(30);
person.speak();
}
}
class DemoBean{
static void main(String[] args){
Person person = new Person();
person.setName("diffo");
person.setAge(30);
person.speak();
}
}
五.初始化类成员变量的方式
方式一:在构造方法执行前进行赋值,并且该类每个实现的对象,都会被初始化为该值。
意义:当我们真的需要一个类的所有对象某些成员变量的值一致的时候。
方式二:提供外界可访问到的方法,在方法中进行赋值。
意义:动态的修改成员变量的值。
方式三:通过构造方法进行直接赋值
意义:可以在创建对象的同时进行赋值,同时还可以动态的指定设定的值是什么。
例子:
public class DemoClassTest{
public static void main(String[] args){
//第一种方式:
//在构造方法执行前进行赋值,并且该类每个实现的对象,都会被初始化为该值.
//意义: 当我们真的需要一个类的所有对象某些成员变量的值一致的时候。
Person person = new Person();
person.entity = "Japan";
person.showEntity();
//第二种方式
//构造方法中直接进行赋值.
//意义: 可以在创建对象的同时进行赋值,同时还可以动态的指定设定的值是什么
Person person1 = new Person(40);
person1.showEntity();
//第三种方式
//通过调用某个设置值的方法进行赋值,在对象创建完成之后
//意义: 动态的修改成员变量的值.
Person person2 = new Person();
person2.showEntity();
//person.age = 12 //error
/*
person.setAge(12);
person.eat();
Person person1 = new Person();
person1.setAge(15);
person1.eat();
*/
}
}
class Person{
//改成员变量就不可被外部访问(外部: 类之外)
int age=20;
static String entity;
//是给成员变量赋值
//优先原则: 对于一个方法来说,如果传递的形参的变量名称和类的成员变量名称相同,jvm在处理的时候优先当做方法的形参来处理.
Person(){
}
Person(int age){
this.age = age;
}
void setAge(int age){
this.age = age;
}
//拿到成员变量的值
int getAge(){
return this.age;
}
void eat(){
System.out.println("eat :"+this.age);
speak();
}
void outputAge(){
System.out.println(this.age);
}
void speak(){
System.out.println("speak!");
}
void showEntity(){
System.out.println("Entity:"+entity);
}
}
六.static
a.随着类加载而加载(静态方法区中来保存静态成员变量)
b.优先于对象创建。
c.被类的所有对象共享,静态的成员变量会保存在该class的静态方法区中,所以每个对象都看到的都是同一份。
d.可以通过类名来访问也可以通过对象名来访问。(效果是一样的)
e.推荐通过类名来访问。
f.静态的成员,一般称为类相关的成员。
static 既可以修饰成员变量,也可以修饰成员方法,且修饰之后,就可以通过类名来直接访问到。
g.this变量在静态方法中不可以使用。
h.静态方法中只能访问静态成员变量和静态方法。
非静态方法既可以访问静态成员和方法,也可以访问非静态成员和方法。
非静态方法虽然可以访问静态方法,但不介意这样做。
例子:
public class DemoStatic{
public static void main(String[] args){
Person person = new Person();
Person.action();
//Person.speak();
/*
person.name="ryan";
System.out.println(new Person().name);
System.out.println(Person.name);
*/
method();
}
static void method(){
System.out.println("method");
}
}
class Person{
static String name = "diffo";
static int age = 20;
void speak(){
System.out.println("speak:"+age);
}
static void action(){
speak();
}
}
七.main方法
修饰符 返回类型 方法名(参数列表){
}
public static void main(String[] args){
}
public:最大的一个访问权限,使得jvm能够成功调用。
static:类相关的,与对象无关。A.main([]);
public class A{
main(){
System.("");
}
}
void:不需要返回值。
方法名:main
参数列表:执行的时候,可以传递参数。
八.工具类
全部都是静态的方法,所以可以通过类名.function()来访问。
一般的话,都会对默认构造方法进行私有化处理,来防止别人使用时习惯性的创建对象来调用方法。
例子:
//工具类: 都是把其中的方法定义为static
public class MathUtil{
//加法
static int sum(int num1,int num2){
return num1+num2;
}
//减法,乘法
private MathUtil(){
}
public static void main(String[] args){
System.out.println(MathUtil.sum(2,3));
new User().getResult();
}
}
class User{
void getResult(){
System.out.println(MathUtil.sum(2,3));
}
}
day07
一.代码块
1.概念:使用{}括起来的代码,称为代码块。
2.分类:根据它的位置和声明的不同,我们可以将代码块分为局部代码块,构造代码块,静态代码块,同步代码 块(多线程中涉及)。
(1)局部代码块:限定了变量的生命周期,变量在局部代码块中定义的,那么出来局部代码块之后,就访问 不到了。在局部代码块中定义的变量在出了代码块之后,内存就会释放掉。
作用:节约内存。
注意:局部代码中定义的变量,虽然说作用域是局部的,但是如果存在外部嵌套的代码块,且在局部代 码块定义之前就定义了某个变量,那么我们局部的代码块中就不可以定义相同名称的变量。
但是如果在局部代码块执行之后,去定义一个和局部代码块中相同名称的变量,是可以的。因为 局部代码块中的变量已经失去了作用域范围。
例:
public static void main(String[] args){
int x=20;//错误
{
int x=10;
}
int x=20;//正确,上面代码块释放
System.out.println(x);
}
(2)构造代码快
a.概念:类中方法外出现,每次调用构造方法的时候,都会优先调用构造代码块。
b.特点:创建一个对象,都会调用一次构造代码块。
c.作用:如果存在很多重载的构造方法,而且每个里面需要执行相同的逻辑,那么就可以考虑,将这些 代码提取到构造代码块中来;让代码结构更简单,增强了维护性。
(3)静态代码块
a.概念:类中方法外出现,但是用static来进行修饰。
b.特点:随着类加载的时候执行。
c.用处:适用于整个软件生命周期中,只需要执行一次业务逻辑代码。
二.继承
1.子类继承父类,继承父类的成员变量和成员方法。但是他们各自拥有的各自的成员变量,所以他们的值,并不 会继承。
2.对于父类中的私有成员变量和私有方法,子类是无法继承的。
继承的优点:
a.提高了代码的复用性。
b.提高了代码的维护性。
继承的缺点:
类的耦合性增强了。
开发的原则:高内聚,低耦合。
3.只支持单继承,但是可以支持多层继承。
继承是相互叠加的,子类继承的时候,会递归似的寻找父类中是否还存在继承,会继承整个层级直到最根部 类的属性和方法。
4.对于构造方法是无法继承的,但是有办法可以调用父类的构造方法。
5.继承关系中访问成员变量:
(1)不同名的成员变量:
子类可以直接访问和使用父类继承的非私有的成员变量
(2)同名的成员变量:
优先原则:如果子类继承了和父类中相同名字的成员变量,会优先访问子类的该变量。
如果依然想要访问到父类中的同名变量,我们需要加上super关键字来获取。
this:当前对象的引用,可以访问到子类中的变量,也可以访问到父类中的变量。
super:父类对象的引用,只可以访问父类中的变量。
6.继承关系中访问成员方法:
(1)不同名的方法:子类可以直接调用父类的方法。
(2)同名的方法:(同名方法:返回值类型,方法名称以及方法接收的形参列表要一模一样)
当父类和子类出现同名方法的时候,在这种情况下,当我们子类调用该方法时,会有优 先原则的处理,就是会调用子类的该方法。
7.方法的重写:存在于继承关系中,子类中定义的方法和父类中的方法完全一样的时候(返回值类型父子类关系 是可以的),我们在通过子类访问该方法的时候,就会调用到子类的方法。
方法重载:同一个类中,如果我们有多个相同方法名的方法但是他们的形参列表是不同的,那么这种方式我们 就称为方法的重载。在调用的时候,jvm能够通过不同的形参来区分我们到底调用的是哪个方法。
8.关于方法重写和方法重载的返回值约束:
方法重载:仅返回值不同是不能重载的,必须参数列表不同。
方法重写:返回值类型(父子类关系是可以的)要求返回值类型也要相同的。
补充:
我们一个文件在编译之后产生的.class文件的数量,取决于该文件中定义的class的数量(非内部类)而且是 不引入其他类的情况下。
9.继承中构造方法的调用:
特点:
(1)创建子类对象的时候,一定会优先去创建父类对象,所以就需要调用到父类的构造方法。
(2)对于我们所有的类构造方法的第一行,如果我们没有自己添加this(...)或者super(...)的情况下,都 会去帮我们默认的添加super().
如果父类中不存在默认的构造,子类依然要创建对象,那么子类就需要显示的指明调用的是哪一个父类对 象,才能保证父类对象创建的成功。
明确一点:
a.一定要保证父类对象的创建成功。
b.构造方法的第一行,如果我们添加了自己调用的this(...)或者super(...),系统就不会为我们默认 的添加super().
c.我们的this(...)或者super(...)必须放到第一行,二者只能有其一。
三.final关键字
a.final修饰类
final如果修饰一个类,该类不能被继承。
b.修饰类的成员变量(修饰成员变量,该值不可改变)。
问题:那么什么时候初始化这个值?
答:在对象创建之前都可以。
(1)构造代码块中可以进行初始化
(2)构造方法中可以进行初始化
(3)定义成员变量的时候,可以直接进行初始化
注意:三种方式同时只能使用一种。
在大多数的场景下,我们的final成员变量会配合public static一起使用。
例:class A{
public static final double PI=3.14;
}//常量类,变量名都要大写,而且单词之间要用_分隔开
c.静态成员变量初始化时机:
(1)在创建静态final成员变量的时候,直接进行初始化
(2)在静态代码块中进行初始化。
作业:
1.
package task;
/*1. 定义一个工具类
其中提供了对于整形数组和double类型数组的一些工具方法。
方法分别有:
1.求数组值的和.2.求数组中的最大值3.对数组进行升序排序.
4.对数组进行倒序排序(也就是反转数组)
工具类要求:
a.私有化构造方法b.不希望被继承*/
public class Tools {
private Tools(){//私有化默认构造方法
}
public static void main(String[] args){
Tools tools=new Tools();
//静态初始化
//int[]arr=new int[]{7,9,2,0,1,6,4,3,5,8};
//tools.intArrAdd(arr);
//tools.intArrMax(arr);
//tools.intSortAsc(arr);
//tools.intArrRev(arr);
double[]arr=new double[]{7.03,9.08,2.07,0.0,1.23,6.67,4.71,3.09,5.33,8.21};
tools.doubleArrRev(arr);
}
private void intArrAdd(int []arr){//数组的和
int sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
System.out.println("数组的和为:"+sum);;
}
private void intArrMax(int[]arr){//数组中的最大数
int max=0;
for(int i=0;i<arr.length;i++){
if(max<arr[i]){
max=arr[i];
}
}
System.out.println("数组中最大的数为:"+max);;
}
private void intSortAsc(int[]arr){//使用选择排序进行升序排序
int temp;
System.out.println("升序排序后的数组为:");
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
System.out.print(arr[i]);
System.out.print(" ");
}
}
private void intArrRev(int[]arr){//反转数组
int temp;
System.out.println("反转后的数组为:");
for(int i=0;i<arr.length/2;i++){
temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
System.out.print(" ");
}
}
private void doubleArrAdd(double []arr){//数组的和
double sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
System.out.println("数组的和为:"+sum);;
}
private void doubleArrMax(double[]arr){//数组中的最大数
double max=0;
for(int i=0;i<arr.length;i++){
if(max<arr[i]){
max=arr[i];
}
}
System.out.println("数组中最大的数为:"+max);;
}
private void doubleSortAsc(double[]arr){//使用选择排序进行升序排序
double temp;
System.out.println("升序排序后的数组为:");
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
System.out.print(arr[i]);
System.out.print(" ");
}
}
private void doubleArrRev(double[]arr){//反转数组
double temp;
System.out.println("反转后的数组为:");
for(int i=0;i<arr.length/2;i++){
temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
System.out.print(" ");
}
}
}
2.
package task;
/*a.定义一个英雄类 Hero 属性:(全部私有,提供公共方法让外部访问)
年龄, 血量 ,攻击力,防御力 方法:释放技能,加血.
必须至少包含一个构造方法,且该构造方法可以初始化所有四个成员变量
b.定义一个类BatMan继承Hero类 方法:飞行(方法中输出一行打印"飞行")
c.定义一个SuperBatMan类继承 BatMan类
方法:重写飞行方法(方法中输出一行打印"超级飞行")
最终分别创建BatMan对象和SuperBatMan对象,并调用飞行方法.*/
public class Hero {
Hero(){
age=18;
blood=100;
attack=100;
defend=100;
}
private int age;
private int blood;
private int attack;
private int defend;
void releaseSkills(){
System.out.println("释放技能");
}
void addBlood(){
System.out.println("加血");
}
public static void main(String[] args){
BatMan batman=new BatMan();
batman.fly();
batman.releaseSkills();
batman.addBlood();
SuperBatMan superbatman=new SuperBatMan();
superbatman.fly();
superbatman.releaseSkills();
superbatman.addBlood();
}
}
class BatMan extends Hero{
void fly(){
System.out.println("飞行");
}
}
class SuperBatMan extends BatMan{
void fly(){
System.out.println("超级飞行");
}
}
3.
package task;
import java.util.*;
/*实现一个猜数的小游戏.随机产生一个数(a)。
Scanner 的方式来输入一个数字,并提供反馈,
告诉用户该输入的值比a大还是比a小,直到最终用户猜中,显示结果.
*/
public class Task3 {
int num;
int a;
void inputNum(){
Random d=new Random();
int a=d.nextInt(10);
System.out.println("请输入一个数字:");
Scanner sc=new Scanner(System.in);
num=sc.nextInt();
if(num<a){
System.out.println("输入的值比a小,请重新输入!");
inputNum();
}else if(num>a){
System.out.println("输入的值比a大,请重新输入!");
inputNum();
}else{
System.out.println("恭喜你猜中了!本次产生的随机数是:"+num);
}
}
public static void main(String[] args){
Task3 t=new Task3();
t.inputNum();
}
}
c语言作业
1.
#include <stdio.h>
//给你任意三个整型数据,找出其中最大一个整型数
void main(){
int arr[3];
printf("请输入任意三个整型数据:\n");
scanf("%d %d %d" ,&arr[0],&arr[1],&arr[2]);
int max=0;
for(int i=0;i<3;i++){
if(arr[i]>max){
max=arr[i];
}
}
printf("最大的一个整型数是:%d\n",max);
}
2.#include<stdio.h>
//求1+2!+3!+...+20!的和
void main(){
int sum=0;
int mul=1;
for(int i=1;i<=20;i++){
for(int j=1;j<=i;j++){
mul*=j;
}
sum+=mul;
}
printf("1+2!+3!+...+20!的和为: %d\n",sum);
}
3.#include<stdio.h>
//编程完成数据加密,数据是五位的整数,加密规则为:每位数字都加上6,然后用和除以8的余数代替该数字,再将第一位和第五位交换,第二位和第四位交换
void main(){
int a;
printf("请输入要加密的五位的整数:\n");
scanf("%d",&a);
//得到每一位的数字
int b1=a/10000;
int b2=(a%(b1*10000))/1000;
int b3=(a%(b1*10000+b2*1000))/100;
int b4=(a%(b1*10000+b2*1000+b3*100))/10;
int b5=a%(b1*10000+b2*1000+b3*100+b4*10);
//加上6,和除以8取余
int c1=(b1+6)%8;
int c2=(b2+6)%8;
int c3=(b3+6)%8;
int c4=(b4+6)%8;
int c5=(b5+6)%8;
//交换
int temp1,temp2;
temp1=c1;
c1=c5;
c5=temp1;
temp2=c2;
c2=c4;
c4=temp2;
int sum=c1*10000+c2*1000+c3*100+c4*10+c5;
printf("加密后的数字为:%d\n",sum);
}